QuicChromiumClientStream handle Read() after trailers are received but not yet delivered

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/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 347 matching lines @@
 
   stream_->OnStreamHeaders(uncompressed_trailers);
   stream_->OnStreamHeadersComplete(true, uncompressed_trailers.length());
 
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_,
               OnHeadersAvailableMock(_, uncompressed_trailers.length()))
       .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) {
@@ skipping 40 matching lines @@
   EXPECT_FALSE(stream_->IsDoneReading());
 
   base::RunLoop run_loop2;
   EXPECT_CALL(delegate_,
               OnHeadersAvailableMock(_, uncompressed_trailers.length()))
       .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), StringPiece())),
+          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_);
 
   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());
+
+  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());
+
+  // 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()))
+      .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), StringPiece())),
+          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_);
+
+  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);
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   TestCompletionCallback callback;
@@ skipping 91 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(headers_, delegate_.headers_);
 
   // Times(2) because OnClose will be called for stream and stream_.
   EXPECT_CALL(delegate_, OnClose()).Times(2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net