Move the "wait for QUIC handshake confirmation" logic to QuicChromiumClientSession::StreamRequest

net/quic/chromium/quic_chromium_client_session_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_session.h"
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
@@ skipping 189 matching lines @@
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Request a stream and verify that a stream was created.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
   EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
 
   quic_data.Resume();
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
+TEST_P(QuicChromiumClientSessionTest, ConfirmationRequiredStreamRequest) {
+  MockQuicData quic_data;
+  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddRead(ASYNC, ERR_IO_PENDING);
+  quic_data.AddRead(ASYNC, OK);  // EOF
+  quic_data.AddSocketDataToFactory(&socket_factory_);
+
+  Initialize();
+  CompleteCryptoHandshake();
+
+  // Request a stream and verify that a stream was created.
+  std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
+      session_->CreateStreamRequest(/*requires_confirmation=*/true);
+  TestCompletionCallback callback;
+  ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
+  EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
+
+  quic_data.Resume();
+  EXPECT_TRUE(quic_data.AllReadDataConsumed());
+  EXPECT_TRUE(quic_data.AllWriteDataConsumed());
+}
+
+TEST_P(QuicChromiumClientSessionTest, StreamRequestBeforeConfirmation) {
+  MockQuicData quic_data;
+  quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
+  quic_data.AddRead(ASYNC, ERR_IO_PENDING);
+  quic_data.AddRead(ASYNC, OK);  // EOF
+  quic_data.AddSocketDataToFactory(&socket_factory_);
+
+  Initialize();
+
+  // Request a stream and verify that a stream was created.
+  std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
+      session_->CreateStreamRequest(/*requires_confirmation=*/true);
+  TestCompletionCallback callback;
+  ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
+
+  CompleteCryptoHandshake();
+
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
+
+  EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
+
+  quic_data.Resume();
+  EXPECT_TRUE(quic_data.AllReadDataConsumed());
+  EXPECT_TRUE(quic_data.AllWriteDataConsumed());
+}
+
 TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) {
   MockQuicData quic_data;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1,
                                                  QUIC_STREAM_CANCELLED));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Request a stream and cancel it without releasing the stream.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
   stream_request.reset();
 
   quic_data.Resume();
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
@@ skipping 11 matching lines @@
   // Open the maximum number of streams so that a subsequent request
   // can not proceed immediately.
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     session_->CreateOutgoingDynamicStream(kDefaultPriority);
   }
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
   // Close a stream and ensure the stream request completes.
   QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_CANCELLED, 0);
   session_->OnRstStream(rst);
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
 
@@ skipping 17 matching lines @@
   // Open the maximum number of streams so that a subsequent request
   // can not proceed immediately.
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     session_->CreateOutgoingDynamicStream(kDefaultPriority);
   }
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
   // Cancel the pending stream request.
   stream_request.reset();
 
   // Close a stream and ensure that no new stream is created.
   QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_CANCELLED, 0);
   session_->OnRstStream(rst);
   EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams());
@@ skipping 10 matching lines @@
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Pump the message loop to read the connection close packet.
   base::RunLoop().RunUntilIdle();
 
   // Request a stream and verify that it failed.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_CONNECTION_CLOSED,
             stream_request->StartRequest(callback.callback()));
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
+TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeHandshakeConfirmed) {
+  MockQuicData quic_data;
+  quic_data.AddRead(ASYNC, ERR_IO_PENDING);
+  quic_data.AddRead(server_maker_.MakeConnectionClosePacket(1));
+  quic_data.AddSocketDataToFactory(&socket_factory_);
+
+  Initialize();
+
+  // Request a stream and verify that it's pending.
+  std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
+      session_->CreateStreamRequest(/*requires_confirmation=*/true);
+  TestCompletionCallback callback;
+  ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
+
+  // Close the connection and verify that the StreamRequest completes with
+  // an error.
+  quic_data.Resume();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
+
+  EXPECT_TRUE(quic_data.AllReadDataConsumed());
+  EXPECT_TRUE(quic_data.AllWriteDataConsumed());
+}
+
 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseWithPendingStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(server_maker_.MakeConnectionClosePacket(1));
   quic_data.AddSocketDataToFactory(&socket_factory_);
 
   Initialize();
   CompleteCryptoHandshake();
 
   // Open the maximum number of streams so that a subsequent request
   // can not proceed immediately.
   const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     session_->CreateOutgoingDynamicStream(kDefaultPriority);
   }
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
   // Close the connection and verify that the StreamRequest completes with
   // an error.
   quic_data.Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
 
@@ skipping 346 matching lines @@
 
   std::vector<QuicChromiumClientStream*> streams;
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     QuicChromiumClientStream* stream =
         session_->CreateOutgoingDynamicStream(kDefaultPriority);
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
 
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest();
+      session_->CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
   // Close a stream and ensure I can now open a new one.
   QuicStreamId stream_id = streams[0]->id();
   session_->CloseStream(stream_id);
   QuicRstStreamFrame rst1(stream_id, QUIC_STREAM_NO_ERROR, 0);
   session_->OnRstStream(rst1);
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
@@ skipping 330 matching lines @@
 
   EXPECT_TRUE(socket_data_->AllReadDataConsumed());
   EXPECT_TRUE(socket_data_->AllWriteDataConsumed());
   EXPECT_TRUE(new_socket_data.AllReadDataConsumed());
   EXPECT_TRUE(new_socket_data.AllWriteDataConsumed());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net