Add an async ReadBody method to QuicChromiumClientStream::Handle

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 33 matching lines @@
 
   MOCK_METHOD0(OnSendData, int());
   MOCK_METHOD2(OnSendDataComplete, int(int, bool*));
   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) {}
-
-  void OnDataAvailable() override {}
-};
-
 class MockQuicClientSessionBase : public QuicClientSessionBase {
  public:
   explicit MockQuicClientSessionBase(QuicConnection* connection,
                                      QuicClientPushPromiseIndex* index);
   ~MockQuicClientSessionBase() override;
 
   const QuicCryptoStream* GetCryptoStream() const override {
     return crypto_stream_.get();
   }
 
@@ skipping 50 matching lines @@
       WriteHeadersMock,
       size_t(QuicStreamId id,
              const SpdyHeaderBlock& headers,
              bool fin,
              SpdyPriority priority,
              const QuicReferenceCountedPointer<QuicAckListenerInterface>&
                  ack_listener));
   MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
 
   std::unique_ptr<QuicStream> CreateStream(QuicStreamId id) {
-    return QuicMakeUnique<TestQuicClientSessionBaseStream>(id, this);
+    return QuicMakeUnique<QuicChromiumClientStream>(id, this,
+                                                    NetLogWithSource());
   }
 
   using QuicSession::ActivateStream;
 
   // Returns a QuicConsumedData that indicates all of |data| (and |fin| if set)
   // has been consumed.
   static QuicConsumedData ConsumeAllData(
       QuicStreamId id,
       const QuicIOVector& data,
       QuicStreamOffset offset,
@@ skipping 108 matching lines @@
   }
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
   }
 
   QuicStreamId GetNthServerInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(session_, n);
   }
 
+  void ResetStreamCallback(QuicChromiumClientStream* stream, int /*rv*/) {
+    stream->Reset(QUIC_STREAM_CANCELLED);
+  }
+
   QuicCryptoClientConfig crypto_config_;
   std::unique_ptr<QuicChromiumClientStream::Handle> handle_;
   testing::StrictMock<MockDelegate> delegate_;
   std::unique_ptr<QuicChromiumClientStream::Handle> handle2_;
   testing::StrictMock<MockDelegate> delegate2_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicClientSessionBase session_;
   QuicChromiumClientStream* stream_;
   SpdyHeaderBlock headers_;
@@ skipping 105 matching lines @@
 
 TEST_P(QuicChromiumClientStreamTest, OnFinRead) {
   InitializeHeaders();
   QuicStreamOffset offset = 0;
   ProcessHeadersFull(headers_);
   QuicStreamFrame frame2(kTestStreamId, true, offset, QuicStringPiece());
   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();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
+  int data_len = strlen(data);
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
-  EXPECT_CALL(delegate_, OnDataAvailable())
-      .WillOnce(testing::Invoke(CreateFunctor(
-          &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
-          QuicStringPiece(data, arraysize(data) - 1))));
+  // Read the body and verify that it arrives correctly.
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  EXPECT_EQ(data_len,
+            handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
+  EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
+
+  EXPECT_CALL(delegate_, OnClose());
+}
+
+TEST_P(QuicChromiumClientStreamTest, OnDataAvailableEarly) {

[xunjieli, 2017/05/12 15:22:22]

Why is this testing OnDataAvailable Early?
The OnStreamFrame happens after handle_->ReadBody(), right?
Should this be OnDataAvailableLate or OnDataAvailableAfterReadBody?

[Ryan Hamilton, 2017/05/12 17:26:24]

Good point. Done.

+  InitializeHeaders();
+  ProcessHeadersFull(headers_);
+
+  const char data[] = "hello world!";
+  int data_len = strlen(data);
+
+  // Start to read the body.
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
+
+  stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
+                                         /*offset=*/0, data));
+
+  EXPECT_EQ(data_len, callback.WaitForResult());
+  EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(delegate_, OnClose());
 }
 
 TEST_P(QuicChromiumClientStreamTest, ProcessHeadersWithError) {
   SpdyHeaderBlock bad_headers;
   bad_headers["NAME"] = "...";
   EXPECT_CALL(session_,
               SendRstStream(kTestStreamId, QUIC_BAD_APPLICATION_PAYLOAD, 0));
 
   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();
   auto headers = AsHeaderList(headers_);
   ProcessHeadersFull(headers_);
   EXPECT_CALL(session_, SendRstStream(kTestStreamId, QUIC_STREAM_CANCELLED, 0));
 
   const char data[] = "hello world!";
+  int data_len = strlen(data);
+
+  // Start to read the body.
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  EXPECT_EQ(ERR_IO_PENDING,
+            handle_->ReadBody(
+                buffer.get(), 2 * data_len,
+                base::Bind(&QuicChromiumClientStreamTest::ResetStreamCallback,
+                           base::Unretained(this), stream_)));
+
+  // Receive the data and close the stream during the callback.
   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)).Times(1);
 
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
+  int data_len = strlen(data);
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
-  EXPECT_CALL(delegate_, OnDataAvailable())
-      .WillOnce(testing::Invoke(CreateFunctor(
-          &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
-          QuicStringPiece(data, arraysize(data) - 1))));
+  // Read the body and verify that it arrives correctly.
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  EXPECT_EQ(data_len,
+            handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
+  EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
 
   auto t = ProcessTrailers(trailers);
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_,
               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();
+  // Read the body and verify that it arrives correctly.
+  EXPECT_EQ(0,
+            handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
 
   // Make sure kFinalOffsetHeaderKey is gone from the delivered actual trailers.
   trailers.erase(kFinalOffsetHeaderKey);
   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_);
 
   const char data[] = "hello world!";
+  int data_len = strlen(data);
   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),
-              QuicStringPiece(data, arraysize(data) - 1))),
-          testing::Invoke([&run_loop]() { run_loop.Quit(); })));
-
-  // Wait for the read to complete.
-  run_loop.Run();
+  // Read the body and verify that it arrives correctly.
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  EXPECT_EQ(data_len,
+            handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
+  EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
 
   // 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));
+  EXPECT_THAT(
+      handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()),
+      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_,
               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();
+  // Read the body and verify that it arrives correctly.
+  EXPECT_EQ(0, callback.WaitForResult());
 
   // 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_.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();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
+  int data_len = strlen(data);
   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),
-              QuicStringPiece(data, arraysize(data) - 1))),
-          testing::Invoke([&run_loop]() { run_loop.Quit(); })));
-
-  // Wait for the read to complete.
-  run_loop.Run();
+  // Read the body and verify that it arrives correctly.
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buffer(new IOBuffer(2 * data_len));
+  EXPECT_EQ(data_len,
+            handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
+  EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len));
 
   // Deliver trailers. Delegate notification is posted asynchronously.
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
 
   QuicHeaderList t = ProcessTrailers(trailers);
 
+  EXPECT_FALSE(stream_->IsDoneReading());
   // Read again, it return ERR_IO_PENDING.
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
-  EXPECT_THAT(stream_->Read(buffer.get(), 1), ERR_IO_PENDING);
+  EXPECT_THAT(
+      handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()),
+      IsError(ERR_IO_PENDING));
 
   // Trailers are not delivered
   EXPECT_FALSE(stream_->IsDoneReading());
 
   base::RunLoop run_loop2;
   EXPECT_CALL(delegate_,
               OnTrailingHeadersAvailableMock(_, t.uncompressed_header_bytes()))
       .WillOnce(
           testing::InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
 
   run_loop2.Run();
 
-  base::RunLoop run_loop3;
+  // Read the body and verify that it arrives correctly.
   // 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();
+  EXPECT_EQ(0, callback.WaitForResult());
 
   // 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_.trailers_);
 
   base::RunLoop().RunUntilIdle();
@@ skipping 149 matching lines @@
   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