Split QuicChromiumClientStreamDelegate::OnHeadersAvailable into

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 26 matching lines @@
 namespace {
 
 const QuicStreamId kTestStreamId = 5u;
 
 class MockDelegate : public QuicChromiumClientStream::Delegate {
  public:
   MockDelegate() {}
 
   MOCK_METHOD0(OnSendData, int());
   MOCK_METHOD2(OnSendDataComplete, int(int, bool*));
-  void OnHeadersAvailable(const SpdyHeaderBlock& headers,
-                          size_t frame_len) override {
+  void OnInitialHeadersAvailable(const SpdyHeaderBlock& headers,
+                                 size_t frame_len) override {
     headers_ = headers.Clone();
-    OnHeadersAvailableMock(headers, frame_len);
+    OnInitialHeadersAvailableMock(headers, frame_len);
   }
-  MOCK_METHOD2(OnHeadersAvailableMock,
+  MOCK_METHOD2(OnInitialHeadersAvailableMock,
+               void(const SpdyHeaderBlock& headers, size_t frame_len));
+  void OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers,
+                                  size_t frame_len) override {
+    trailers_ = headers.Clone();
+    OnTrailingHeadersAvailableMock(headers, frame_len);
+  }
+  MOCK_METHOD2(OnTrailingHeadersAvailableMock,
                void(const SpdyHeaderBlock& headers, size_t frame_len));
   MOCK_METHOD2(OnDataReceived, int(const char*, int));
   MOCK_METHOD0(OnDataAvailable, void());
   MOCK_METHOD0(OnClose, void());
   MOCK_METHOD1(OnError, void(int));
   MOCK_METHOD0(HasSendHeadersComplete, bool());
 
   SpdyHeaderBlock headers_;
+  SpdyHeaderBlock trailers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
 class TestQuicClientSessionBaseStream : public QuicSpdyStream {
  public:
   TestQuicClientSessionBaseStream(QuicStreamId id, QuicSpdySession* session)
       : QuicSpdyStream(id, session) {}
 
@@ skipping 175 matching lines @@
   }
 
   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()));
+    EXPECT_CALL(delegate_, OnInitialHeadersAvailableMock(
+                               _, h.uncompressed_header_bytes()));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(headers, delegate_.headers_);
     EXPECT_TRUE(stream_->header_list().empty());
     return h;
   }
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
   }
 
@@ skipping 102 matching lines @@
           &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
           QuicStringPiece(data, arraysize(data) - 1))));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
 
   auto t = ProcessTrailers(trailers);
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, t.uncompressed_header_bytes()))
+              OnTrailingHeadersAvailableMock(_, 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),
                                         QuicStringPiece())),
           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_);
+  EXPECT_EQ(trailers, delegate_.trailers_);
   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();
   ProcessHeadersFull(headers_);
 
@@ skipping 18 matching lines @@
   EXPECT_THAT(stream_->Read(buffer.get(), 1), IsError(ERR_IO_PENDING));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
   QuicHeaderList t = ProcessTrailers(trailers);
   EXPECT_FALSE(stream_->IsDoneReading());
 
   base::RunLoop run_loop2;
   EXPECT_CALL(delegate_,
-              OnHeadersAvailableMock(_, t.uncompressed_header_bytes()))
+              OnTrailingHeadersAvailableMock(_, 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(
           testing::Invoke(CreateFunctor(&QuicChromiumClientStreamTest::ReadData,
                                         base::Unretained(this),
                                         QuicStringPiece())),
           testing::InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); })));
   run_loop3.Run();
 
   // Make sure the stream is properly closed since trailers and data are all
   // consumed.
   EXPECT_TRUE(stream_->IsDoneReading());
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, delegate_.headers_);
+  EXPECT_EQ(trailers, delegate_.trailers_);
 
   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();
@@ skipping 24 matching lines @@
 
   // 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(_, t.uncompressed_header_bytes()))
+              OnTrailingHeadersAvailableMock(_, 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,
                                         base::Unretained(this),
                                         QuicStringPiece())),
           testing::Invoke([&run_loop3]() { run_loop3.Quit(); })));
   run_loop3.Run();
 
   // Make sure the stream is properly closed since trailers and data are all
   // consumed.
   EXPECT_TRUE(stream_->IsDoneReading());
 
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
-  EXPECT_EQ(trailers, delegate_.headers_);
+  EXPECT_EQ(trailers, delegate_.trailers_);
 
   base::RunLoop().RunUntilIdle();
   EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, WriteStreamData) {
   EXPECT_CALL(delegate_, OnClose());
 
   const char kData1[] = "hello world";
   const size_t kDataLen = arraysize(kData1);
@@ skipping 86 matching lines @@
 
   InitializeHeaders();
 
   // Receive the headers before the delegate is set.
   QuicHeaderList header_list = AsHeaderList(headers_);
   stream2->OnStreamHeaderList(true, header_list.uncompressed_header_bytes(),
                               header_list);
   EXPECT_TRUE(delegate2_.headers_.empty());
 
   // Now set the delegate and verify that the headers are delivered.
-  EXPECT_CALL(delegate2_, OnHeadersAvailableMock(
+  EXPECT_CALL(delegate2_, OnInitialHeadersAvailableMock(
                               _, header_list.uncompressed_header_bytes()));
   stream2->SetDelegate(&delegate2_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(headers_, delegate2_.headers_);
 
   // Both delegates should be notified that theirs streams are closed.
   EXPECT_CALL(delegate2_, OnClose());
   EXPECT_CALL(delegate_, OnClose());
 }
 
@@ skipping 11 matching lines @@
   QuicHeaderList header_list = AsHeaderList(headers_);
   stream2->OnStreamHeaderList(false, header_list.uncompressed_header_bytes(),
                               header_list);
   EXPECT_TRUE(delegate2_.headers_.empty());
   const char data[] = "hello world!";
   stream2->OnStreamFrame(QuicStreamFrame(stream_id, /*fin=*/false,
                                          /*offset=*/0, data));
 
   // Now set the delegate and verify that the headers are delivered, but
   // not the data, which needs to be read explicitly.
-  EXPECT_CALL(delegate2_, OnHeadersAvailableMock(
+  EXPECT_CALL(delegate2_, OnInitialHeadersAvailableMock(
                               _, header_list.uncompressed_header_bytes()));
   stream2->SetDelegate(&delegate2_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(headers_, delegate2_.headers_);
   base::RunLoop().RunUntilIdle();
 
   // Now explicitly read the data.
   int data_len = arraysize(data) - 1;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1));
   ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1));
   EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
 
   // Both delegates should be notified that theirs streams are closed.
   EXPECT_CALL(delegate2_, OnClose());
   EXPECT_CALL(delegate_, OnClose());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net