Deletes dead code.

net/quic/chromium/quic_chromium_client_stream_test.cc

Index: net/quic/chromium/quic_chromium_client_stream_test.cc
diff --git a/net/quic/chromium/quic_chromium_client_stream_test.cc b/net/quic/chromium/quic_chromium_client_stream_test.cc
index 84f97bf50b53ff47ca92dcbcfcdd2262185f86df..c856d01995d8bb6416d27e3c85dd9d16f90033ef 100644
--- a/net/quic/chromium/quic_chromium_client_stream_test.cc
+++ b/net/quic/chromium/quic_chromium_client_stream_test.cc
@@ -217,6 +217,28 @@ class QuicChromiumClientStreamTest
               StringPiece(buffer->data(), expected_data.length()));
   }
 
+  QuicHeaderList ProcessHeaders(const SpdyHeaderBlock& headers) {
+    QuicHeaderList h = AsHeaderList(headers);
+    stream_->OnStreamHeaderList(false, h.uncompressed_header_bytes(), h);
+    return h;
+  }
+
+  QuicHeaderList ProcessTrailers(const SpdyHeaderBlock& headers) {
+    QuicHeaderList h = AsHeaderList(headers);
+    stream_->OnStreamHeaderList(true, h.uncompressed_header_bytes(), h);
+    return h;
+  }
+
+  QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) {
+    QuicHeaderList h = ProcessHeaders(headers);
+    EXPECT_CALL(delegate_,
+                OnHeadersAvailableMock(_, h.uncompressed_header_bytes()));
+    base::RunLoop().RunUntilIdle();
+    EXPECT_EQ(headers, delegate_.headers_);
+    EXPECT_TRUE(stream_->header_list().empty());
+    return h;
+  }
+
   QuicCryptoClientConfig crypto_config_;
   testing::StrictMock<MockDelegate> delegate_;
   MockQuicConnectionHelper helper_;
@@ -233,18 +255,8 @@ INSTANTIATE_TEST_CASE_P(Version,
 
 TEST_P(QuicChromiumClientStreamTest, OnFinRead) {
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
   QuicStreamOffset offset = 0;
-  stream_->OnStreamHeaders(uncompressed_headers);
-  stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
-  EXPECT_TRUE(stream_->decompressed_headers().empty());
-
+  ProcessHeadersFull(headers_);
   QuicStreamFrame frame2(kTestStreamId, true, offset, StringPiece());
   EXPECT_CALL(delegate_, OnClose());
   stream_->OnStreamFrame(frame2);
@@ -259,16 +271,7 @@ TEST_P(QuicChromiumClientStreamTest, OnDataAvailableBeforeHeaders) {
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailable) {
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(uncompressed_headers);
-  stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
-  EXPECT_TRUE(stream_->decompressed_headers().empty());
+  ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
@@ -285,12 +288,14 @@ TEST_P(QuicChromiumClientStreamTest, OnDataAvailable) {
 }
 
 TEST_P(QuicChromiumClientStreamTest, ProcessHeadersWithError) {
-  std::string bad_headers = "...";
+  SpdyHeaderBlock bad_headers;
+  bad_headers["NAME"] = "...";
   EXPECT_CALL(session_,
               SendRstStream(kTestStreamId, QUIC_BAD_APPLICATION_PAYLOAD, 0));
 
-  stream_->OnStreamHeaders(StringPiece(bad_headers));
-  stream_->OnStreamHeadersComplete(false, bad_headers.length());
+  auto headers = AsHeaderList(bad_headers);
+  stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+                              headers);
 
   base::RunLoop().RunUntilIdle();
 
@@ -299,16 +304,8 @@ TEST_P(QuicChromiumClientStreamTest, ProcessHeadersWithError) {
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailableWithError) {
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(uncompressed_headers);
-  stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
-  EXPECT_TRUE(stream_->decompressed_headers().empty());
+  auto headers = AsHeaderList(headers_);
+  ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
@@ -331,16 +328,7 @@ TEST_P(QuicChromiumClientStreamTest, OnError) {
 
 TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(uncompressed_headers);
-  stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
-  EXPECT_TRUE(stream_->decompressed_headers().empty());
+  ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
@@ -354,15 +342,11 @@ TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
-  std::string uncompressed_trailers =
-      SpdyUtils::SerializeUncompressedHeaders(trailers);
-
-  stream_->OnStreamHeaders(uncompressed_trailers);
-  stream_->OnStreamHeadersComplete(true, uncompressed_trailers.length());
 
+  auto t = ProcessTrailers(trailers);
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_trailers.length()))
+              OnHeadersAvailableMock(_, t.uncompressed_header_bytes()))
       .WillOnce(testing::InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
 
   run_loop.Run();
@@ -388,16 +372,7 @@ TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
 // immediately notified about trailers.
 TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(uncompressed_headers);
-  stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
-  EXPECT_TRUE(stream_->decompressed_headers().empty());
+  ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
@@ -422,16 +397,12 @@ TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
-  std::string uncompressed_trailers =
-      SpdyUtils::SerializeUncompressedHeaders(trailers);
-
-  stream_->OnStreamHeaders(uncompressed_trailers);
-  stream_->OnStreamHeadersComplete(true, uncompressed_trailers.length());
+  QuicHeaderList t = ProcessTrailers(trailers);
   EXPECT_FALSE(stream_->IsDoneReading());
 
   base::RunLoop run_loop2;
   EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_trailers.length()))
+              OnHeadersAvailableMock(_, t.uncompressed_header_bytes()))
       .WillOnce(
           testing::InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
 
@@ -463,16 +434,7 @@ TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
 // of 0 (EOF).
 TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream_->OnStreamHeaders(uncompressed_headers);
-  stream_->OnStreamHeadersComplete(false, uncompressed_headers.length());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
-  EXPECT_TRUE(stream_->decompressed_headers().empty());
+  ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
@@ -494,11 +456,8 @@ TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
-  std::string uncompressed_trailers =
-      SpdyUtils::SerializeUncompressedHeaders(trailers);
 
-  stream_->OnStreamHeaders(uncompressed_trailers);
-  stream_->OnStreamHeadersComplete(true, uncompressed_trailers.length());
+  QuicHeaderList t = ProcessTrailers(trailers);
 
   // Read again, it return ERR_IO_PENDING.
   scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
@@ -509,7 +468,7 @@ TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
 
   base::RunLoop run_loop2;
   EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_trailers.length()))
+              OnHeadersAvailableMock(_, t.uncompressed_header_bytes()))
       .WillOnce(
           testing::InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
 
@@ -628,17 +587,8 @@ TEST_P(QuicChromiumClientStreamTest, HeadersBeforeDelegate) {
   session_.ActivateStream(base::WrapUnique(stream));
 
   InitializeHeaders();
-  std::string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  stream->OnStreamHeaders(uncompressed_headers);
-  stream->OnStreamHeadersComplete(false, uncompressed_headers.length());
-  EXPECT_TRUE(stream->decompressed_headers().empty());
-
-  EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, uncompressed_headers.length()));
   stream->SetDelegate(&delegate_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(headers_, delegate_.headers_);
+  ProcessHeadersFull(headers_);
 
   // Times(2) because OnClose will be called for stream and stream_.
   EXPECT_CALL(delegate_, OnClose()).Times(2);