Add a new QuicChromiumClientSession::Handle class

net/quic/chromium/quic_chromium_client_session_test.cc

Index: net/quic/chromium/quic_chromium_client_session_test.cc
diff --git a/net/quic/chromium/quic_chromium_client_session_test.cc b/net/quic/chromium/quic_chromium_client_session_test.cc
index 2ac521305b457e265ea593dcd845e8d1fbf41ac8..4f17ff73b955db8427bebd141b913c93a02178ee 100644
--- a/net/quic/chromium/quic_chromium_client_session_test.cc
+++ b/net/quic/chromium/quic_chromium_client_session_test.cc
@@ -89,6 +89,7 @@ class QuicChromiumClientSessionTest
             new SequencedSocketData(default_read_.get(), 1, nullptr, 0)),
         random_(0),
         helper_(&clock_, &random_),
+        server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
         client_maker_(GetParam(),
                       0,
                       &clock_,
@@ -121,8 +122,7 @@ class QuicChromiumClientSessionTest
         connection, std::move(socket),
         /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
         &transport_security_state_,
-        base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
-        QuicServerId(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
+        base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)), server_id_,
         /*require_confirmation=*/false, kQuicYieldAfterPacketsRead,
         QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
         /*cert_verify_flags=*/0, DefaultQuicConfig(), &crypto_config_,
@@ -141,7 +141,8 @@ class QuicChromiumClientSessionTest
   }
 
   void TearDown() override {
-    session_->CloseSessionOnError(ERR_ABORTED, QUIC_INTERNAL_ERROR);
+    if (session_)
+      session_->CloseSessionOnError(ERR_ABORTED, QUIC_INTERNAL_ERROR);
   }
 
   void CompleteCryptoHandshake() {
@@ -170,6 +171,7 @@ class QuicChromiumClientSessionTest
   TransportSecurityState transport_security_state_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   QuicClientPushPromiseIndex push_promise_index_;
+  QuicServerId server_id_;
   std::unique_ptr<QuicChromiumClientSession> session_;
   TestServerPushDelegate test_push_delegate_;
   QuicConnectionVisitorInterface* visitor_;
@@ -195,6 +197,111 @@ TEST_P(QuicChromiumClientSessionTest, CryptoConnect) {
   CompleteCryptoHandshake();
 }
 
+TEST_P(QuicChromiumClientSessionTest, GetHandle) {
+  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();
+
+  NetLogWithSource session_net_log = session_->net_log();
+  EXPECT_EQ(NetLogSourceType::QUIC_SESSION, session_net_log.source().type);
+  EXPECT_EQ(&net_log_, session_net_log.net_log());
+
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
+  EXPECT_TRUE(handle.IsConnected());
+  EXPECT_FALSE(handle.IsCryptoHandshakeConfirmed());
+  EXPECT_EQ(GetParam(), handle.GetQuicVersion());
+  EXPECT_EQ(server_id_, handle.server_id());
+  EXPECT_EQ(session_net_log.source().type, handle.net_log().source().type);
+  EXPECT_EQ(session_net_log.source().id, handle.net_log().source().id);
+  EXPECT_EQ(session_net_log.net_log(), handle.net_log().net_log());
+  IPEndPoint address;
+  EXPECT_EQ(OK, handle.GetPeerAddress(&address));
+  EXPECT_EQ(kIpEndPoint, address);
+  EXPECT_TRUE(handle.CreatePacketBundler(QuicConnection::NO_ACK).get() !=
+              nullptr);
+  {
+    // Verify that the copy constructor works as expected.
+    QuicChromiumClientSession::Handle handle2(handle);
+    EXPECT_TRUE(handle2.IsConnected());
+    EXPECT_FALSE(handle2.IsCryptoHandshakeConfirmed());
+  }
+
+  CompleteCryptoHandshake();
+
+  EXPECT_TRUE(handle.IsCryptoHandshakeConfirmed());
+
+  // Request a stream and verify that a stream was created.
+  auto stream_request =
+      handle.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());
+
+  // Veirfy that the handle works correctly after the session is closed.
+  EXPECT_FALSE(handle.IsConnected());
+  EXPECT_TRUE(handle.IsCryptoHandshakeConfirmed());
+  EXPECT_EQ(GetParam(), handle.GetQuicVersion());
+  EXPECT_EQ(server_id_, handle.server_id());
+  EXPECT_EQ(session_net_log.source().type, handle.net_log().source().type);
+  EXPECT_EQ(session_net_log.source().id, handle.net_log().source().id);
+  EXPECT_EQ(session_net_log.net_log(), handle.net_log().net_log());
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, handle.GetPeerAddress(&address));
+  EXPECT_TRUE(handle.CreatePacketBundler(QuicConnection::NO_ACK).get() ==
+              nullptr);
+  {
+    // Verify that the copy constructor works as expected, even after the
+    // session is closed.
+    QuicChromiumClientSession::Handle handle2(handle);
+    EXPECT_FALSE(handle2.IsConnected());
+    EXPECT_TRUE(handle2.IsCryptoHandshakeConfirmed());
+  }
+
+  {
+    // Verify that GetHandle() works even after the session is closed.
+    QuicChromiumClientSession::Handle handle2 = session_->GetHandle();
+    EXPECT_FALSE(handle2.IsConnected());
+    EXPECT_TRUE(handle2.IsCryptoHandshakeConfirmed());
+  }
+
+  auto stream_request2 =
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
+  ASSERT_EQ(ERR_CONNECTION_CLOSED,
+            stream_request->StartRequest(callback.callback()));
+
+  session_.reset();
+
+  // Veirfy that the handle works correctly after the session is delete.
+  EXPECT_FALSE(handle.IsConnected());
+  EXPECT_TRUE(handle.IsCryptoHandshakeConfirmed());
+  EXPECT_EQ(GetParam(), handle.GetQuicVersion());
+  EXPECT_EQ(server_id_, handle.server_id());
+  EXPECT_EQ(session_net_log.source().type, handle.net_log().source().type);
+  EXPECT_EQ(session_net_log.source().id, handle.net_log().source().id);
+  EXPECT_EQ(session_net_log.net_log(), handle.net_log().net_log());
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, handle.GetPeerAddress(&address));
+  EXPECT_TRUE(handle.CreatePacketBundler(QuicConnection::NO_ACK).get() ==
+              nullptr);
+  auto stream_request3 =
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
+  ASSERT_EQ(ERR_CONNECTION_CLOSED,
+            stream_request->StartRequest(callback.callback()));
+  {
+    // Verify that the copy constructor works as expected, even after the
+    // session is deleted.
+    QuicChromiumClientSession::Handle handle2(handle);
+    EXPECT_FALSE(handle2.IsConnected());
+    EXPECT_TRUE(handle2.IsCryptoHandshakeConfirmed());
+  }
+}
+
 TEST_P(QuicChromiumClientSessionTest, StreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr));
@@ -206,8 +313,9 @@ TEST_P(QuicChromiumClientSessionTest, StreamRequest) {
   CompleteCryptoHandshake();
 
   // Request a stream and verify that a stream was created.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
   EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
@@ -228,8 +336,9 @@ TEST_P(QuicChromiumClientSessionTest, ConfirmationRequiredStreamRequest) {
   CompleteCryptoHandshake();
 
   // Request a stream and verify that a stream was created.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/true);
+      handle.CreateStreamRequest(/*requires_confirmation=*/true);
   TestCompletionCallback callback;
   ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
   EXPECT_TRUE(stream_request->ReleaseStream() != nullptr);
@@ -249,8 +358,9 @@ TEST_P(QuicChromiumClientSessionTest, StreamRequestBeforeConfirmation) {
   Initialize();
 
   // Request a stream and verify that a stream was created.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/true);
+      handle.CreateStreamRequest(/*requires_confirmation=*/true);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
@@ -278,8 +388,9 @@ TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) {
   CompleteCryptoHandshake();
 
   // Request a stream and cancel it without releasing the stream.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(OK, stream_request->StartRequest(callback.callback()));
   stream_request.reset();
@@ -310,8 +421,9 @@ TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
@@ -348,8 +460,9 @@ TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
@@ -379,8 +492,9 @@ TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) {
   base::RunLoop().RunUntilIdle();
 
   // Request a stream and verify that it failed.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_CONNECTION_CLOSED,
             stream_request->StartRequest(callback.callback()));
@@ -398,8 +512,9 @@ TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeHandshakeConfirmed) {
   Initialize();
 
   // Request a stream and verify that it's pending.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/true);
+      handle.CreateStreamRequest(/*requires_confirmation=*/true);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
@@ -433,8 +548,9 @@ TEST_P(QuicChromiumClientSessionTest, ConnectionCloseWithPendingStreamRequest) {
   EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Request a stream and verify that it's pending.
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));
 
@@ -800,8 +916,9 @@ TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
     streams.push_back(stream);
   }
 
+  QuicChromiumClientSession::Handle handle = session_->GetHandle();
   std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request =
-      session_->CreateStreamRequest(/*requires_confirmation=*/false);
+      handle.CreateStreamRequest(/*requires_confirmation=*/false);
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback()));