Fix QuicChromiumClientStreamTest.HeadersBeforeDelegate to actually set

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 252 matching lines @@
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
   }
 
   QuicStreamId GetNthServerInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(session_, n);
   }
 
   QuicCryptoClientConfig crypto_config_;
+  testing::StrictMock<MockDelegate> delegate2_;
   testing::StrictMock<MockDelegate> delegate_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicClientSessionBase session_;
   QuicChromiumClientStream* stream_;
   SpdyHeaderBlock headers_;
   QuicClientPushPromiseIndex push_promise_index_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
@@ skipping 325 matching lines @@
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(buf2->size(), true)));
   stream_->OnCanWrite();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 TEST_P(QuicChromiumClientStreamTest, HeadersBeforeDelegate) {
   // We don't use stream_ because we want an incoming server push
   // stream.
-  QuicChromiumClientStream* stream = new QuicChromiumClientStream(
-      GetNthServerInitiatedStreamId(0), &session_, NetLogWithSource());
-  session_.ActivateStream(base::WrapUnique(stream));
+  QuicStreamId stream_id = GetNthServerInitiatedStreamId(0);
+  QuicChromiumClientStream* stream2 =
+      new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource());
+  session_.ActivateStream(base::WrapUnique(stream2));
 
   InitializeHeaders();
-  stream->SetDelegate(&delegate_);
-  ProcessHeadersFull(headers_);
 
-  // Times(2) because OnClose will be called for stream and stream_.
-  EXPECT_CALL(delegate_, OnClose()).Times(2);
+  // 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(
+                              _, 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());
+}
+
+TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeDelegate) {
+  // We don't use stream_ because we want an incoming server push
+  // stream.
+  QuicStreamId stream_id = GetNthServerInitiatedStreamId(0);
+  QuicChromiumClientStream* stream2 =
+      new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource());
+  session_.ActivateStream(base::WrapUnique(stream2));
+
+  InitializeHeaders();
+
+  // Receive the headers and data before the delegate is set.
+  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(
+                              _, 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