Create a QuicChromiumClientStream::Handle class for allowing a stream

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 188 matching lines @@
   QuicChromiumClientStreamTest()
       : crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
         session_(new MockQuicConnection(&helper_,
                                         &alarm_factory_,
                                         Perspective::IS_CLIENT,
                                         SupportedVersions(GetParam())),
                  &push_promise_index_) {
     stream_ = new QuicChromiumClientStream(kTestStreamId, &session_,
                                            NetLogWithSource());
     session_.ActivateStream(base::WrapUnique(stream_));
-    stream_->SetDelegate(&delegate_);
+    handle_ = stream_->CreateHandle(&delegate_);
   }
 
   void InitializeHeaders() {
     headers_[":host"] = "www.google.com";
     headers_[":path"] = "/index.hml";
     headers_[":scheme"] = "https";
     headers_["cookie"] =
         "__utma=208381060.1228362404.1372200928.1372200928.1372200928.1; "
         "__utmc=160408618; "
         "GX=DQAAAOEAAACWJYdewdE9rIrW6qw3PtVi2-d729qaa-74KqOsM1NVQblK4VhX"
@@ skipping 51 matching lines @@
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n);
   }
 
   QuicStreamId GetNthServerInitiatedStreamId(int n) {
     return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(session_, n);
   }
 
   QuicCryptoClientConfig crypto_config_;
+  std::unique_ptr<QuicChromiumClientStream::Handle> handle_;
+  testing::StrictMock<MockDelegate> delegate_;
+  std::unique_ptr<QuicChromiumClientStream::Handle> handle2_;
   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,
                         QuicChromiumClientStreamTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
+TEST_P(QuicChromiumClientStreamTest, Handle) {
+  EXPECT_TRUE(handle_->IsOpen());
+  EXPECT_EQ(kTestStreamId, handle_->id());
+  EXPECT_EQ(QUIC_NO_ERROR, handle_->connection_error());
+  EXPECT_EQ(QUIC_STREAM_NO_ERROR, handle_->stream_error());
+  EXPECT_TRUE(handle_->IsFirstStream());
+  EXPECT_FALSE(handle_->IsDoneReading());
+  EXPECT_FALSE(handle_->fin_sent());
+  EXPECT_FALSE(handle_->fin_received());
+  EXPECT_EQ(0u, handle_->stream_bytes_read());
+  EXPECT_EQ(0u, handle_->stream_bytes_written());
+  EXPECT_EQ(0u, handle_->NumBytesConsumed());
+
+  InitializeHeaders();
+  QuicStreamOffset offset = 0;
+  ProcessHeadersFull(headers_);
+  QuicStreamFrame frame2(kTestStreamId, true, offset, QuicStringPiece());
+  EXPECT_CALL(delegate_, OnClose());
+  stream_->OnStreamFrame(frame2);
+  EXPECT_TRUE(handle_->fin_received());
+  handle_->OnFinRead();
+
+  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;
+  EXPECT_EQ(OK, handle_->WriteStreamData(QuicStringPiece(kData1, kDataLen),
+                                         true, callback.callback()));
+
+  EXPECT_FALSE(handle_->IsOpen());
+  EXPECT_EQ(kTestStreamId, handle_->id());
+  EXPECT_EQ(QUIC_NO_ERROR, handle_->connection_error());
+  EXPECT_EQ(QUIC_STREAM_NO_ERROR, handle_->stream_error());
+  EXPECT_TRUE(handle_->IsFirstStream());
+  EXPECT_TRUE(handle_->IsDoneReading());
+  EXPECT_TRUE(handle_->fin_sent());
+  EXPECT_TRUE(handle_->fin_received());
+  EXPECT_EQ(0u, handle_->stream_bytes_read());
+  EXPECT_EQ(kDataLen, handle_->stream_bytes_written());
+  EXPECT_EQ(0u, handle_->NumBytesConsumed());
+
+  EXPECT_EQ(ERR_CONNECTION_CLOSED,
+            handle_->WriteStreamData(QuicStringPiece(kData1, kDataLen), true,
+                                     callback.callback()));
+
+  std::vector<scoped_refptr<IOBuffer>> buffers = {
+      scoped_refptr<IOBuffer>(new IOBuffer(10))};
+  std::vector<int> lengths = {10};
+  EXPECT_EQ(
+      ERR_CONNECTION_CLOSED,
+      handle_->WritevStreamData(buffers, lengths, true, callback.callback()));
+
+  SpdyHeaderBlock headers;
+  EXPECT_EQ(0u, handle_->WriteHeaders(std::move(headers), true, nullptr));
+}
+
+TEST_P(QuicChromiumClientStreamTest, HandleAfterConnectionClose) {
+  // Verify that the delegate's OnClose is called after closing the connection.
+  EXPECT_CALL(delegate_, OnClose());
+  EXPECT_CALL(session_,
+              SendRstStream(kTestStreamId, QUIC_RST_ACKNOWLEDGEMENT, 0));
+  stream_->OnConnectionClosed(QUIC_INVALID_FRAME_DATA,
+                              ConnectionCloseSource::FROM_PEER);
+
+  EXPECT_FALSE(handle_->IsOpen());
+  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, handle_->connection_error());
+}
+
+TEST_P(QuicChromiumClientStreamTest, HandleAfterStreamReset) {
+  // Verify that the delegate's OnClose is called after the stream is reset,
+  // but that the Handle still behaves correctly.
+  EXPECT_CALL(delegate_, OnClose());
+  QuicRstStreamFrame rst(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
+  EXPECT_CALL(session_,
+              SendRstStream(kTestStreamId, QUIC_RST_ACKNOWLEDGEMENT, 0));
+  stream_->OnStreamReset(rst);
+
+  EXPECT_FALSE(handle_->IsOpen());
+  EXPECT_EQ(QUIC_STREAM_CANCELLED, handle_->stream_error());
+}
+
+TEST_P(QuicChromiumClientStreamTest, HandleAfterClearDelegate) {
+  EXPECT_TRUE(handle_->IsOpen());
+  handle_->ClearDelegate();
+
+  // Verify that the delegate's OnClose is not called after ClearDelegate.
+  EXPECT_CALL(delegate_, OnClose()).Times(0);
+  QuicRstStreamFrame rst(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
+  EXPECT_CALL(session_,
+              SendRstStream(kTestStreamId, QUIC_RST_ACKNOWLEDGEMENT, 0));
+  stream_->OnStreamReset(rst);
+
+  EXPECT_FALSE(handle_->IsOpen());
+  EXPECT_EQ(QUIC_STREAM_CANCELLED, handle_->stream_error());
+}
+
 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) {
@@ skipping 47 matching lines @@
   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));
+  EXPECT_CALL(delegate_, OnError(ERR_INTERNET_DISCONNECTED)).Times(1);
 
   stream_->OnError(ERR_INTERNET_DISCONNECTED);
-  EXPECT_FALSE(stream_->GetDelegate());
+  stream_->OnError(ERR_INTERNET_DISCONNECTED);
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
   const char data[] = "hello world!";
   stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false,
                                          /*offset=*/0, data));
 
@@ skipping 257 matching lines @@
 
   // 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_, OnInitialHeadersAvailableMock(
                               _, header_list.uncompressed_header_bytes()));
-  stream2->SetDelegate(&delegate2_);
+  handle2_ = stream2->CreateHandle(&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
@@ skipping 11 matching lines @@
                               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_, OnInitialHeadersAvailableMock(
                               _, header_list.uncompressed_header_bytes()));
-  stream2->SetDelegate(&delegate2_);
+  handle2_ = stream2->CreateHandle(&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