QUIC - Crash when there is a bad packet loss and the session is closed.

net/quic/quic_stream_factory_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/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 1728 matching lines @@
                                 "GET", net_log_, callback_.callback()));
 
   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
       &factory_, host_port_pair_, is_https_);
 
   DVLOG(1) << "Create 1st session and test packet loss";
 
   // Set packet_loss_rate to a lower value than packet_loss_threshold.
   EXPECT_FALSE(
       factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/0.9f));
+  EXPECT_TRUE(session->connection()->connected());
   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
       &factory_, host_port_pair_, is_https_));
   EXPECT_FALSE(
       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
                    &factory_, host_port_pair_.port()));
 
   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
   // and that should close the session, but shouldn't disable QUIC.
   EXPECT_TRUE(
@@ skipping 27 matching lines @@
                    &factory_, server2.port()));
   EXPECT_FALSE(
       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
 
   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
   // and that should close the session, but shouldn't disable QUIC.
   EXPECT_TRUE(
       factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
                    &factory_, server2.port()));
+  EXPECT_FALSE(session2->connection()->connected());
   EXPECT_FALSE(
       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
   EXPECT_FALSE(
       QuicStreamFactoryPeer::HasActiveSession(&factory_, server2, is_https_));
   EXPECT_EQ(nullptr, CreateIfSessionExists(server2, net_log_).get());
 
   DVLOG(1) << "Create 3rd session which also has packet loss";
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(&factory_);
   EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_, "GET",
                                  net_log_, callback3.callback()));
   QuicClientSession* session3 =
       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
 
   // Set packet_loss_rate to higher value than packet_loss_threshold 2nd time in
   // a row and that should close the session and disable QUIC.
   EXPECT_TRUE(
       factory_.OnHandshakeConfirmed(session3, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
                    &factory_, server3.port()));
+  EXPECT_FALSE(session2->connection()->connected());
   EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server3.port()));
   EXPECT_FALSE(
       QuicStreamFactoryPeer::HasActiveSession(&factory_, server3, is_https_));
   EXPECT_EQ(nullptr, CreateIfSessionExists(server3, net_log_).get());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
   EXPECT_TRUE(socket_data3.at_read_eof());
   EXPECT_TRUE(socket_data3.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net