Deletes dead code.

net/quic/chromium/quic_chromium_client_stream_test.cc

 // Copyright (c) 2012 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/chromium/quic_chromium_client_stream.h"
 
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 199 matching lines @@
   }
 
   void ReadData(StringPiece expected_data) {
     scoped_refptr<IOBuffer> buffer(new IOBuffer(expected_data.length() + 1));
     EXPECT_EQ(static_cast<int>(expected_data.length()),
               stream_->Read(buffer.get(), expected_data.length() + 1));
     EXPECT_EQ(expected_data,
               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_;
   MockAlarmFactory alarm_factory_;
   MockQuicClientSessionBase session_;
   QuicChromiumClientStream* stream_;
   SpdyHeaderBlock headers_;
   QuicClientPushPromiseIndex push_promise_index_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         QuicChromiumClientStreamTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 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);
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnDataAvailableBeforeHeaders) {
   EXPECT_CALL(delegate_, OnClose());
 
   EXPECT_CALL(delegate_, OnDataAvailable()).Times(0);
   stream_->OnDataAvailable();
 }
 
 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,
                                          /*offset=*/0, data));
 
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(&QuicChromiumClientStreamTest::ReadData,
                         base::Unretained(this),
                         StringPiece(data, arraysize(data) - 1))));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(delegate_, OnClose());
 }
 
 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();
 
   EXPECT_CALL(delegate_, OnClose());
 }
 
 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,
                                          /*offset=*/0, data));
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(CreateFunctor(
           &QuicChromiumClientStream::Reset,
           base::Unretained(stream_), QUIC_STREAM_CANCELLED)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnError) {
   EXPECT_CALL(delegate_, OnError(ERR_INTERNET_DISCONNECTED));
 
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
   EXPECT_FALSE(stream_->GetDelegate());
 }
 
 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,
                                          /*offset=*/0, data));
 
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::Invoke(CreateFunctor(
           &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
           StringPiece(data, arraysize(data) - 1))));
 
   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();
 
   // OnDataAvailable callback should follow trailers notification.
   base::RunLoop run_loop3;
   EXPECT_CALL(delegate_, OnDataAvailable())
       .Times(1)
       .WillOnce(testing::DoAll(
           testing::Invoke(CreateFunctor(&QuicChromiumClientStreamTest::ReadData,
                                         base::Unretained(this), StringPiece())),
           testing::InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); })));
   run_loop3.Run();
 
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
   EXPECT_EQ(trailers, delegate_.headers_);
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(delegate_, OnClose());
 }
 
 // Tests that trailers are marked as consumed only before delegate is to be
 // 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,
                                          /*offset=*/0, data));
 
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_, OnDataAvailable())
       .Times(1)
       .WillOnce(testing::DoAll(
           testing::Invoke(CreateFunctor(
               &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
               StringPiece(data, arraysize(data) - 1))),
           testing::Invoke([&run_loop]() { run_loop.Quit(); })));
 
   // Wait for the read to complete.
   run_loop.Run();
 
   // Read again, and it will be pending.
   scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
   EXPECT_THAT(stream_->Read(buffer.get(), 1), IsError(ERR_IO_PENDING));
 
   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(); }));
 
   run_loop2.Run();
 
   // OnDataAvailable callback should follow trailers notification.
   base::RunLoop run_loop3;
   EXPECT_CALL(delegate_, OnDataAvailable())
       .Times(1)
       .WillOnce(testing::DoAll(
@@ skipping 11 matching lines @@
 
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(delegate_, OnClose());
 }
 
 // Test that if Read() is called after response body is read and after trailers
 // are received but not yet delivered, Read() will return ERR_IO_PENDING instead
 // 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,
                                          /*offset=*/0, data));
 
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_, OnDataAvailable())
       .Times(1)
       .WillOnce(testing::DoAll(
           testing::Invoke(CreateFunctor(
               &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
               StringPiece(data, arraysize(data) - 1))),
           testing::Invoke([&run_loop]() { run_loop.Quit(); })));
 
   // Wait for the read to complete.
   run_loop.Run();
 
   // Deliver trailers. Delegate notification is posted asynchronously.
   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));
   EXPECT_THAT(stream_->Read(buffer.get(), 1), ERR_IO_PENDING);
 
   // Trailers are not delivered
   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(); }));
 
   run_loop2.Run();
 
   base::RunLoop run_loop3;
   // OnDataAvailable() should follow right after and Read() will return 0.
   EXPECT_CALL(delegate_, OnDataAvailable())
       .WillOnce(testing::DoAll(
           testing::Invoke(CreateFunctor(&QuicChromiumClientStreamTest::ReadData,
@@ skipping 98 matching lines @@
 }
 
 TEST_P(QuicChromiumClientStreamTest, HeadersBeforeDelegate) {
   // We don't use stream_ because we want an incoming server push
   // stream.
   QuicChromiumClientStream* stream = new QuicChromiumClientStream(
       kServerDataStreamId1, &session_, NetLogWithSource());
   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);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net