Deletes dead code.

net/quic/core/quic_spdy_stream_test.cc

 // Copyright 2013 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.
 
 #include "net/quic/core/quic_spdy_stream.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 92 matching lines @@
         SupportedVersions(GetParam()));
     session_.reset(new testing::StrictMock<MockQuicSpdySession>(connection_));
     stream_ = new TestStream(kClientDataStreamId1, session_.get(),
                              stream_should_process_data);
     session_->ActivateStream(base::WrapUnique(stream_));
     stream2_ = new TestStream(kClientDataStreamId2, session_.get(),
                               stream_should_process_data);
     session_->ActivateStream(base::WrapUnique(stream2_));
   }
 
+  QuicHeaderList ProcessHeaders(bool fin, const SpdyHeaderBlock& headers) {
+    QuicHeaderList h = AsHeaderList(headers);
+    stream_->OnStreamHeaderList(fin, h.uncompressed_header_bytes(), h);
+    return h;
+  }
+
  protected:
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicConnection* connection_;
   std::unique_ptr<MockQuicSpdySession> session_;
 
   // Owned by the |session_|.
   TestStream* stream_;
   TestStream* stream2_;
 
   SpdyHeaderBlock headers_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicSpdyStreamTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
-TEST_P(QuicSpdyStreamTest, ProcessHeaders) {
-  Initialize(kShouldProcessData);
-
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
-  stream_->OnStreamHeaders(headers);
-  EXPECT_EQ("", stream_->data());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  EXPECT_EQ(kV3HighestPriority, stream_->priority());
-  EXPECT_EQ("", stream_->data());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-  EXPECT_FALSE(stream_->IsDoneReading());
-}
-
 TEST_P(QuicSpdyStreamTest, ProcessHeaderList) {
   Initialize(kShouldProcessData);
 
-  size_t total_bytes = 0;
-  QuicHeaderList headers;
-  for (auto p : headers_) {
-    headers.OnHeader(p.first, p.second);
-    total_bytes += p.first.size() + p.second.size();
-  }
   stream_->OnStreamHeadersPriority(kV3HighestPriority);
-  stream_->OnStreamHeaderList(false, total_bytes, headers);
+  ProcessHeaders(false, headers_);
   EXPECT_EQ("", stream_->data());
   EXPECT_FALSE(stream_->header_list().empty());
   EXPECT_FALSE(stream_->IsDoneReading());
 }
 
-TEST_P(QuicSpdyStreamTest, ProcessEmptyHeaderList) {
+TEST_P(QuicSpdyStreamTest, ProcessTooLargeHeaderList) {
   FLAGS_quic_limit_uncompressed_headers = true;
   Initialize(kShouldProcessData);
 
   QuicHeaderList headers;
   stream_->OnStreamHeadersPriority(kV3HighestPriority);
 
   EXPECT_CALL(*session_,
               SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0));
   stream_->OnStreamHeaderList(false, 1 << 20, headers);
   EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, stream_->stream_error());
 }
 
-TEST_P(QuicSpdyStreamTest, ProcessHeadersWithFin) {
-  Initialize(kShouldProcessData);
-
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
-  stream_->OnStreamHeaders(headers);
-  EXPECT_EQ("", stream_->data());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-  stream_->OnStreamHeadersComplete(true, headers.size());
-  EXPECT_EQ(kV3HighestPriority, stream_->priority());
-  EXPECT_EQ("", stream_->data());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-  EXPECT_FALSE(stream_->IsDoneReading());
-  EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
-}
-
 TEST_P(QuicSpdyStreamTest, ProcessHeaderListWithFin) {
   Initialize(kShouldProcessData);
 
   size_t total_bytes = 0;
   QuicHeaderList headers;
   for (auto p : headers_) {
     headers.OnHeader(p.first, p.second);
     total_bytes += p.first.size() + p.second.size();
   }
   stream_->OnStreamHeadersPriority(kV3HighestPriority);
@@ skipping 44 matching lines @@
   headers_[":status"] = " 200 ";
   EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code));
 
   headers_[":status"] = "  ";
   EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code));
 }
 
 TEST_P(QuicSpdyStreamTest, MarkHeadersConsumed) {
   Initialize(kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
+  QuicHeaderList headers = ProcessHeaders(false, headers_);
+  EXPECT_EQ(headers, stream_->header_list());
 
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-
-  headers.erase(0, 10);
-  stream_->MarkHeadersConsumed(10);
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-
-  stream_->MarkHeadersConsumed(headers.length());
-  EXPECT_EQ("", stream_->decompressed_headers());
+  stream_->ConsumeHeaderList();
+  EXPECT_EQ(QuicHeaderList(), stream_->header_list());
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBody) {
   Initialize(kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
 
-  stream_->OnStreamHeaders(headers);
   EXPECT_EQ("", stream_->data());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  EXPECT_EQ(headers, stream_->decompressed_headers());
-  stream_->MarkHeadersConsumed(headers.length());
+  QuicHeaderList headers = ProcessHeaders(false, headers_);
+  EXPECT_EQ(headers, stream_->header_list());
+  stream_->ConsumeHeaderList();
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame);
-  EXPECT_EQ("", stream_->decompressed_headers());
+  EXPECT_EQ(QuicHeaderList(), stream_->header_list());
   EXPECT_EQ(body, stream_->data());
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragments) {
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
 
   for (size_t fragment_size = 1; fragment_size < body.size(); ++fragment_size) {
     Initialize(kShouldProcessData);
-    for (size_t offset = 0; offset < headers.size(); offset += fragment_size) {
-      size_t remaining_data = headers.size() - offset;
-      StringPiece fragment(headers.data() + offset,
-                           min(fragment_size, remaining_data));
-      stream_->OnStreamHeaders(fragment);
-    }
-    stream_->OnStreamHeadersComplete(false, headers.size());
-    ASSERT_EQ(headers, stream_->decompressed_headers()) << "fragment_size: "
-                                                        << fragment_size;
-    stream_->MarkHeadersConsumed(headers.length());
+    QuicHeaderList headers = ProcessHeaders(false, headers_);
+    ASSERT_EQ(headers, stream_->header_list());
+    stream_->ConsumeHeaderList();
     for (size_t offset = 0; offset < body.size(); offset += fragment_size) {
       size_t remaining_data = body.size() - offset;
       StringPiece fragment(body.data() + offset,
                            min(fragment_size, remaining_data));
       QuicStreamFrame frame(kClientDataStreamId1, false, offset,
                             StringPiece(fragment));
       stream_->OnStreamFrame(frame);
     }
     ASSERT_EQ(body, stream_->data()) << "fragment_size: " << fragment_size;
   }
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
 
   for (size_t split_point = 1; split_point < body.size() - 1; ++split_point) {
     Initialize(kShouldProcessData);
-    StringPiece headers1(headers.data(), split_point);
-    stream_->OnStreamHeaders(headers1);
-
-    StringPiece headers2(headers.data() + split_point,
-                         headers.size() - split_point);
-    stream_->OnStreamHeaders(headers2);
-    stream_->OnStreamHeadersComplete(false, headers.size());
-    ASSERT_EQ(headers, stream_->decompressed_headers()) << "split_point: "
-                                                        << split_point;
-    stream_->MarkHeadersConsumed(headers.length());
+    QuicHeaderList headers = ProcessHeaders(false, headers_);
+    ASSERT_EQ(headers, stream_->header_list());
+    stream_->ConsumeHeaderList();
 
     StringPiece fragment1(body.data(), split_point);
     QuicStreamFrame frame1(kClientDataStreamId1, false, 0,
                            StringPiece(fragment1));
     stream_->OnStreamFrame(frame1);
 
     StringPiece fragment2(body.data() + split_point, body.size() - split_point);
     QuicStreamFrame frame2(kClientDataStreamId1, false, split_point,
                            StringPiece(fragment2));
     stream_->OnStreamFrame(frame2);
 
     ASSERT_EQ(body, stream_->data()) << "split_point: " << split_point;
   }
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyReadv) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
 
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame);
-  stream_->MarkHeadersConsumed(headers.length());
+  stream_->ConsumeHeaderList();
 
   char buffer[2048];
   ASSERT_LT(body.length(), arraysize(buffer));
   struct iovec vec;
   vec.iov_base = buffer;
   vec.iov_len = arraysize(buffer);
 
   size_t bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(body.length(), bytes_read);
   EXPECT_EQ(body, string(buffer, bytes_read));
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyMarkConsumed) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
 
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame);
-  stream_->MarkHeadersConsumed(headers.length());
+  stream_->ConsumeHeaderList();
 
   struct iovec vec;
 
   EXPECT_EQ(1, stream_->GetReadableRegions(&vec, 1));
   EXPECT_EQ(body.length(), vec.iov_len);
   EXPECT_EQ(body, string(static_cast<char*>(vec.iov_base), vec.iov_len));
 
   stream_->MarkConsumed(body.length());
   EXPECT_EQ(body.length(), stream_->flow_controller()->bytes_consumed());
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame);
-  stream_->MarkHeadersConsumed(headers.length());
+  stream_->ConsumeHeaderList();
 
   char buffer[1];
   struct iovec vec;
   vec.iov_base = buffer;
   vec.iov_len = arraysize(buffer);
 
   for (size_t i = 0; i < body.length(); ++i) {
     size_t bytes_read = stream_->Readv(&vec, 1);
     ASSERT_EQ(1u, bytes_read);
     EXPECT_EQ(body.data()[i], buffer[0]);
   }
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
   Initialize(!kShouldProcessData);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body = "this is the body";
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame);
-  stream_->MarkHeadersConsumed(headers.length());
+  stream_->ConsumeHeaderList();
 
   char buffer1[1];
   char buffer2[1];
   struct iovec vec[2];
   vec[0].iov_base = buffer1;
   vec[0].iov_len = arraysize(buffer1);
   vec[1].iov_base = buffer2;
   vec[1].iov_len = arraysize(buffer2);
 
   for (size_t i = 0; i < body.length(); i += 2) {
@@ skipping 50 matching lines @@
   // Set a small flow control receive window.
   const uint64_t kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
                                               kWindow);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset(
                          stream_->flow_controller()));
 
   // Stream receives enough data to fill a fraction of the receive window.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body;
   GenerateBody(&body, kWindow / 3);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
 
   QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize(
                                          stream_->flow_controller()));
 
   // Now receive another frame which results in the receive window being over
   // half full. This should all be buffered, decreasing the receive window but
   // not sending WINDOW_UPDATE.
   QuicStreamFrame frame2(kClientDataStreamId1, false, kWindow / 3,
@@ skipping 13 matching lines @@
   // Set a small flow control limit.
   const uint64_t kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
                                               kWindow);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset(
                          stream_->flow_controller()));
 
   // Stream receives enough data to fill a fraction of the receive window.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   string body;
   GenerateBody(&body, kWindow / 3);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  stream_->MarkHeadersConsumed(headers.length());
+  ProcessHeaders(false, headers_);
+  stream_->ConsumeHeaderList();
 
   QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize(
                                          stream_->flow_controller()));
 
   // Now receive another frame which results in the receive window being over
   // half full.  This will trigger the stream to increase its receive window
   // offset and send a WINDOW_UPDATE. The result will be again an available
   // window of kWindow bytes.
@@ skipping 24 matching lines @@
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream2_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream2_->flow_controller(),
                                               kWindow);
   QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(session_->flow_controller(),
                                               kWindow);
 
   // Supply headers to both streams so that they are happy to receive data.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  stream_->MarkHeadersConsumed(headers.length());
-  stream2_->OnStreamHeaders(headers);
-  stream2_->OnStreamHeadersComplete(false, headers.size());
-  stream2_->MarkHeadersConsumed(headers.length());
+  auto headers = AsHeaderList(headers_);
+  stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+                              headers);
+  stream_->ConsumeHeaderList();
+  stream2_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+                               headers);
+  stream2_->ConsumeHeaderList();
 
   // Each stream gets a quarter window of data. This should not trigger a
   // WINDOW_UPDATE for either stream, nor for the connection.
   string body;
   GenerateBody(&body, kWindow / 4);
   QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body));
   stream_->OnStreamFrame(frame1);
   QuicStreamFrame frame2(kClientDataStreamId2, false, 0, StringPiece(body));
   stream2_->OnStreamFrame(frame2);
 
@@ skipping 17 matching lines @@
 
   // Stream should not process data, so that data gets buffered in the
   // sequencer, triggering flow control limits.
   Initialize(!kShouldProcessData);
 
   // Set a small flow control limit.
   const uint64_t kWindow = 50;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
 
   // Receive data to overflow the window, violating flow control.
   string body;
   GenerateBody(&body, kWindow + 1);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_P(QuicSpdyStreamTest, TestHandlingQuicRstStreamNoError) {
   Initialize(kShouldProcessData);
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
 
   stream_->OnStreamReset(
       QuicRstStreamFrame(stream_->id(), QUIC_STREAM_NO_ERROR, 0));
   EXPECT_TRUE(stream_->write_side_closed());
   EXPECT_FALSE(stream_->reading_stopped());
 }
 
 TEST_P(QuicSpdyStreamTest, ConnectionFlowControlViolation) {
   // Tests that on if the peer sends too much data (i.e. violates the flow
   // control protocol), at the connection level (rather than the stream level)
   // then we terminate the connection.
 
   // Stream should not process data, so that data gets buffered in the
   // sequencer, triggering flow control limits.
   Initialize(!kShouldProcessData);
 
   // Set a small flow control window on streams, and connection.
   const uint64_t kStreamWindow = 50;
   const uint64_t kConnectionWindow = 10;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kStreamWindow);
   QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(),
                                                  kConnectionWindow);
 
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  ProcessHeaders(false, headers_);
 
   // Send enough data to overflow the connection level flow control window.
   string body;
   GenerateBody(&body, kConnectionWindow + 1);
   EXPECT_LT(body.size(), kStreamWindow);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
 
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
   stream_->OnStreamFrame(frame);
@@ skipping 14 matching lines @@
   string body = "";
   bool fin = true;
 
   EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)).Times(0);
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, fin)));
 
   stream_->WriteOrBufferData(body, fin, nullptr);
 }
 
-TEST_P(QuicSpdyStreamTest, ReceivingTrailers) {
-  // Test that receiving trailing headers from the peer works, and can be read
-  // from the stream and consumed.
+TEST_P(QuicSpdyStreamTest, ReceivingTrailersViaHeaderList) {
+  // Test that receiving trailing headers from the peer via
+  // OnStreamHeaderList() works, and can be read from the stream and consumed.
   Initialize(kShouldProcessData);
 
   // Receive initial headers.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  stream_->MarkHeadersConsumed(stream_->decompressed_headers().size());
+  size_t total_bytes = 0;
+  QuicHeaderList headers;
+  for (const auto& p : headers_) {
+    headers.OnHeader(p.first, p.second);
+    total_bytes += p.first.size() + p.second.size();
+  }
+
+  stream_->OnStreamHeadersPriority(kV3HighestPriority);
+  stream_->OnStreamHeaderList(/*fin=*/false, total_bytes, headers);
+  stream_->ConsumeHeaderList();
 
   // Receive trailing headers.
   SpdyHeaderBlock trailers_block;
   trailers_block["key1"] = "value1";
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
-  trailers_block[kFinalOffsetHeaderKey] = "0";
-  string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
-  stream_->OnStreamHeaders(trailers);
-  stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+  SpdyHeaderBlock trailers_block_with_final_offset = trailers_block.Clone();
+  trailers_block_with_final_offset[kFinalOffsetHeaderKey] = "0";
+  total_bytes = 0;
+  QuicHeaderList trailers;
+  for (const auto& p : trailers_block_with_final_offset) {
+    trailers.OnHeader(p.first, p.second);
+    total_bytes += p.first.size() + p.second.size();
+  }
+  stream_->OnStreamHeaderList(/*fin=*/true, total_bytes, trailers);
 
   // The trailers should be decompressed, and readable from the stream.
   EXPECT_TRUE(stream_->trailers_decompressed());
-  const string decompressed_trailers = stream_->decompressed_trailers();
-  EXPECT_EQ(trailers, decompressed_trailers);
+  EXPECT_EQ(trailers_block, stream_->received_trailers());
 
-  // Consuming the trailers erases them from the stream.
-  stream_->MarkTrailersConsumed(decompressed_trailers.size());
-  EXPECT_EQ("", stream_->decompressed_trailers());
+  // IsDoneReading() returns false until trailers marked consumed.
+  EXPECT_FALSE(stream_->IsDoneReading());
+  stream_->MarkTrailersConsumed();
+  EXPECT_TRUE(stream_->IsDoneReading());
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) {
   // Test that receiving trailers without a final offset field is an error.
   Initialize(kShouldProcessData);
 
   // Receive initial headers.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  stream_->MarkHeadersConsumed(stream_->decompressed_headers().size());
+  auto headers = AsHeaderList(headers_);
+  stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+                              headers);
+  stream_->ConsumeHeaderList();
 
   const string body = "this is the body";
   // Receive trailing headers, without kFinalOffsetHeaderKey.
   SpdyHeaderBlock trailers_block;
   trailers_block["key1"] = "value1";
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
-  string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
-  stream_->OnStreamHeaders(trailers);
+  auto trailers = AsHeaderList(trailers_block);
 
   // Verify that the trailers block didn't contain a final offset.
   EXPECT_EQ("", trailers_block[kFinalOffsetHeaderKey].as_string());
 
   // Receipt of the malformed trailers will close the connection.
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
       .Times(1);
-  stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+  stream_->OnStreamHeaderList(/*fin=*/true,
+                              trailers.uncompressed_header_bytes(), trailers);
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutFin) {
   // Test that received Trailers must always have the FIN set.
   Initialize(kShouldProcessData);
 
   // Receive initial headers.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
+  auto headers = AsHeaderList(headers_);
+  stream_->OnStreamHeaderList(/*fin=*/false,
+                              headers.uncompressed_header_bytes(), headers);
 
   // Receive trailing headers with FIN deliberately set to false.
   SpdyHeaderBlock trailers_block;
-  string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
-  stream_->OnStreamHeaders(trailers);
+  auto trailers = AsHeaderList(trailers_block);
 
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
       .Times(1);
-  stream_->OnStreamHeadersComplete(/*fin=*/false, trailers.size());
+  stream_->OnStreamHeaderList(/*fin=*/false,
+                              trailers.uncompressed_header_bytes(), trailers);
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterFin) {
   // If Trailers are sent, neither Headers nor Body should contain a FIN.
   Initialize(kShouldProcessData);
 
   // Receive initial headers with FIN set.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(/*fin=*/true, headers.size());
+  ProcessHeaders(true, headers_);
 
   // Receive trailing headers after FIN already received.
   SpdyHeaderBlock trailers_block;
-  string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
-  stream_->OnStreamHeaders(trailers);
-
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
       .Times(1);
-  stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+  ProcessHeaders(true, trailers_block);
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterBodyWithFin) {
   // If body data are received with a FIN, no trailers should then arrive.
   Initialize(kShouldProcessData);
 
   // Receive initial headers without FIN set.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size());
+  ProcessHeaders(false, headers_);
 
   // Receive body data, with FIN.
   QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/true, 0, "body");
   stream_->OnStreamFrame(frame);
 
   // Receive trailing headers after FIN already received.
   SpdyHeaderBlock trailers_block;
-  string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
-  stream_->OnStreamHeaders(trailers);
-
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
       .Times(1);
-  stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+  ProcessHeaders(false, trailers_block);
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithOffset) {
   // Test that when receiving trailing headers with an offset before response
   // body, stream is closed at the right offset.
   Initialize(kShouldProcessData);
 
   // Receive initial headers.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(false, headers.size());
-  stream_->MarkHeadersConsumed(stream_->decompressed_headers().size());
+  QuicHeaderList headers = ProcessHeaders(false, headers_);
+  stream_->ConsumeHeaderList();
 
   const string body = "this is the body";
   // Receive trailing headers.
   SpdyHeaderBlock trailers_block;
   trailers_block["key1"] = "value1";
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
   trailers_block[kFinalOffsetHeaderKey] = base::IntToString(body.size());
-  string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
-  stream_->OnStreamHeaders(trailers);
-  stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+
+  QuicHeaderList trailers = ProcessHeaders(true, trailers_block);
 
   // The trailers should be decompressed, and readable from the stream.
   EXPECT_TRUE(stream_->trailers_decompressed());
-  const string decompressed_trailers = stream_->decompressed_trailers();
-  EXPECT_EQ(trailers, decompressed_trailers);
+
+  // The final offset trailer will be consumed by QUIC.
+  trailers_block.erase(kFinalOffsetHeaderKey);
+  EXPECT_EQ(trailers_block, stream_->received_trailers());
+
   // Consuming the trailers erases them from the stream.
-  stream_->MarkTrailersConsumed(decompressed_trailers.size());
   stream_->MarkTrailersConsumed();
-  EXPECT_EQ("", stream_->decompressed_trailers());
+  EXPECT_TRUE(stream_->FinishedReadingTrailers());
 
   EXPECT_FALSE(stream_->IsDoneReading());
   // Receive and consume body.
   QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/false, 0, body);
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(body, stream_->data());
   EXPECT_TRUE(stream_->IsDoneReading());
 }
 
 TEST_P(QuicSpdyStreamTest, ClosingStreamWithNoTrailers) {
   // Verify that a stream receiving headers, body, and no trailers is correctly
   // marked as done reading on consumption of headers and body.
   Initialize(kShouldProcessData);
 
   // Receive and consume initial headers with FIN not set.
-  string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(headers);
-  stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size());
-  stream_->MarkHeadersConsumed(headers.size());
+  auto h = AsHeaderList(headers_);
+  stream_->OnStreamHeaderList(/*fin=*/false, h.uncompressed_header_bytes(), h);
+  stream_->ConsumeHeaderList();
 
   // Receive and consume body with FIN set, and no trailers.
   const string kBody = string(1024, 'x');
   QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/true, 0, kBody);
   stream_->OnStreamFrame(frame);
 
   EXPECT_TRUE(stream_->IsDoneReading());
 }
 
 TEST_P(QuicSpdyStreamTest, WritingTrailersSendsAFin) {
@@ skipping 30 matching lines @@
 
   // Write non-zero body data to force a non-zero final offset.
   const int kBodySize = 1 * 1024;  // 1 MB
   stream_->WriteOrBufferData(string(kBodySize, 'x'), false, nullptr);
 
   // The final offset field in the trailing headers is populated with the
   // number of body bytes written (including queued bytes).
   SpdyHeaderBlock trailers;
   trailers["trailer key"] = "trailer value";
   SpdyHeaderBlock trailers_with_offset(trailers.Clone());
-  trailers_with_offset[kFinalOffsetHeaderKey] = base::IntToString(kBodySize);
+  trailers_with_offset[kFinalOffsetHeaderKey] = base::Uint64ToString(kBodySize);
   EXPECT_CALL(*session_, WriteHeadersMock(_, _, true, _, _));
   stream_->WriteTrailers(std::move(trailers), nullptr);
   EXPECT_EQ(trailers_with_offset, session_->GetWriteHeaders());
 }
 
 TEST_P(QuicSpdyStreamTest, WritingTrailersClosesWriteSide) {
   // Test that if trailers are written after all other data has been written
   // (headers and body), that this closes the stream for writing.
   Initialize(kShouldProcessData);
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
@@ skipping 67 matching lines @@
 
   // Writing Trailers should fail, as the FIN has already been sent.
   // populated with the number of body bytes written.
   EXPECT_QUIC_BUG(stream_->WriteTrailers(SpdyHeaderBlock(), nullptr),
                   "Trailers cannot be sent after a FIN");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net