Update from https://crrev.com/316786

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 16 matching lines @@
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/test_task_runner.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
+using std::ostream;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace test {
 
 namespace {
 const char kDefaultServerHostName[] = "www.google.com";
 const int kDefaultServerPort = 443;
+
+// Run all tests with all the combinations of versions and
+// enable_connection_racing.
+struct TestParams {
+  TestParams(const QuicVersion version, bool enable_connection_racing)
+      : version(version), enable_connection_racing(enable_connection_racing) {}
+
+  friend ostream& operator<<(ostream& os, const TestParams& p) {
+    os << "{ version: " << QuicVersionToString(p.version);
+    os << " enable_connection_racing: " << p.enable_connection_racing << " }";
+    return os;
+  }
+
+  QuicVersion version;
+  bool enable_connection_racing;
+};
+
+// Constructs various test permutations.
+vector<TestParams> GetTestParams() {
+  vector<TestParams> params;
+  QuicVersionVector all_supported_versions = QuicSupportedVersions();
+  for (const QuicVersion version : all_supported_versions) {
+    params.push_back(TestParams(version, false));
+    params.push_back(TestParams(version, true));
+  }
+  return params;
+}
+
 }  // namespace anonymous
 
 class QuicStreamFactoryPeer {
  public:
   static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) {
     return &factory->crypto_config_;
   }
 
   static bool HasActiveSession(QuicStreamFactory* factory,
                                const HostPortPair& host_port_pair,
@@ skipping 37 matching lines @@
 
   static void SetTaskRunner(QuicStreamFactory* factory,
                             base::TaskRunner* task_runner) {
     factory->task_runner_ = task_runner;
   }
 
   static void SetLoadServerInfoTimeout(QuicStreamFactory* factory,
                                        size_t load_server_info_timeout) {
     factory->load_server_info_timeout_ms_ = load_server_info_timeout;
   }
+
+  static void SetEnableConnectionRacing(QuicStreamFactory* factory,
+                                        bool enable_connection_racing) {
+    factory->enable_connection_racing_ = enable_connection_racing;
+  }
+
+  static size_t GetNumberOfActiveJobs(QuicStreamFactory* factory,
+                                      const QuicServerId& server_id) {
+    return (factory->active_jobs_[server_id]).size();
+  }
 };
 
 class MockQuicServerInfo : public QuicServerInfo {
  public:
   MockQuicServerInfo(const QuicServerId& server_id)
       : QuicServerInfo(server_id) {}
   ~MockQuicServerInfo() override {}
 
   void Start() override {}
 
   int WaitForDataReady(const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
+  void ResetWaitForDataReadyCallback() override {}
+
   void CancelWaitForDataReadyCallback() override {}
 
   bool IsDataReady() override { return false; }
 
   bool IsReadyToPersist() override { return false; }
 
   void Persist() override {}
 
   void OnExternalCacheHit() override {}
 };
 
 class MockQuicServerInfoFactory : public QuicServerInfoFactory {
  public:
   MockQuicServerInfoFactory() {}
   ~MockQuicServerInfoFactory() override {}
 
   QuicServerInfo* GetForServer(const QuicServerId& server_id) override {
     return new MockQuicServerInfo(server_id);
   }
 };
 
-
-class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
+class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
  protected:
   QuicStreamFactoryTest()
       : random_generator_(0),
         clock_(new MockClock()),
         runner_(new TestTaskRunner(clock_)),
-        maker_(GetParam(), 0, clock_),
+        maker_(GetParam().version, 0, clock_),
         cert_verifier_(CertVerifier::CreateDefault()),
         channel_id_service_(
             new ChannelIDService(new DefaultChannelIDStore(nullptr),
                                  base::MessageLoopProxy::current())),
         factory_(&host_resolver_,
                  &socket_factory_,
                  base::WeakPtr<HttpServerProperties>(),
                  cert_verifier_.get(),
                  channel_id_service_.get(),
                  &transport_security_state_,
                  &crypto_client_stream_factory_,
                  &random_generator_,
                  clock_,
                  kDefaultMaxPacketSize,
                  std::string(),
-                 SupportedVersions(GetParam()),
+                 SupportedVersions(GetParam().version),
                  /*enable_port_selection=*/true,
                  /*always_require_handshake_confirmation=*/false,
                  /*disable_connection_pooling=*/false,
                  /*load_server_info_timeout=*/0u,
                  /*load_server_info_timeout_srtt_multiplier=*/0.0f,
                  /*enable_truncated_connection_ids=*/true,
+                 /*enable_connection_racing=*/false,
                  QuicTagVector()),
         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
         is_https_(false),
         privacy_mode_(PRIVACY_MODE_DISABLED) {
     factory_.set_require_confirmation(false);
     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
+    QuicStreamFactoryPeer::SetEnableConnectionRacing(
+        &factory_, GetParam().enable_connection_racing);
   }
 
   scoped_ptr<QuicHttpStream> CreateIfSessionExists(
       const HostPortPair& host_port_pair,
       const BoundNetLog& net_log) {
     return QuicStreamFactoryPeer::CreateIfSessionExists(
         &factory_, host_port_pair, false, net_log_);
   }
 
   int GetSourcePortForNewSession(const HostPortPair& destination) {
@@ skipping 53 matching lines @@
     EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get());
     EXPECT_TRUE(socket_data.at_read_eof());
     EXPECT_TRUE(socket_data.at_write_eof());
     return port;
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
     QuicStreamId stream_id = kClientDataStreamId1;
     return maker_.MakeRstPacket(
         1, true, stream_id,
-        AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
+        AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam().version));
   }
 
   MockQuicServerInfoFactory quic_server_info_factory_;
   MockHostResolver host_resolver_;
   DeterministicMockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   MockClock* clock_;  // Owned by factory_.
   scoped_refptr<TestTaskRunner> runner_;
   QuicTestPacketMaker maker_;
   scoped_ptr<CertVerifier> cert_verifier_;
   scoped_ptr<ChannelIDService> channel_id_service_;
   TransportSecurityState transport_security_state_;
   QuicStreamFactory factory_;
   HostPortPair host_port_pair_;
   bool is_https_;
   PrivacyMode privacy_mode_;
   BoundNetLog net_log_;
   TestCompletionCallback callback_;
 };
 
-INSTANTIATE_TEST_CASE_P(Version, QuicStreamFactoryTest,
-                        ::testing::ValuesIn(QuicSupportedVersions()));
+INSTANTIATE_TEST_CASE_P(Version,
+                        QuicStreamFactoryTest,
+                        ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicStreamFactoryTest, CreateIfSessionExists) {
   EXPECT_EQ(nullptr, CreateIfSessionExists(host_port_pair_, net_log_).get());
 }
 
 TEST_P(QuicStreamFactoryTest, Create) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
@@ skipping 1274 matching lines @@
     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config->LookupOrCreate(server_id2);
     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->source_address_token().empty());
     EXPECT_FALSE(cached2->proof_valid());
   }
 }
 
 TEST_P(QuicStreamFactoryTest, CancelWaitForDataReady) {
+  // Don't race quic connections when testing cancel reading of server config
+  // from disk cache.
+  if (GetParam().enable_connection_racing)
+    return;
   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
   const size_t kLoadServerInfoTimeoutMs = 50;
   QuicStreamFactoryPeer::SetLoadServerInfoTimeout(
       &factory_, kLoadServerInfoTimeoutMs);
 
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
@@ skipping 22 matching lines @@
 
   runner_->RunNextTask();
   ASSERT_EQ(0u, runner_->GetPostedTasks().size());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
+TEST_P(QuicStreamFactoryTest, RacingConnections) {
+  if (!GetParam().enable_connection_racing)
+    return;
+  factory_.set_quic_server_info_factory(&quic_server_info_factory_);
+  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
+  const size_t kLoadServerInfoTimeoutMs = 50;
+  QuicStreamFactoryPeer::SetLoadServerInfoTimeout(&factory_,
+                                                  kLoadServerInfoTimeoutMs);
+
+  MockRead reads[] = {
+      MockRead(ASYNC, OK, 0)  // EOF
+  };
+  DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
+  socket_factory_.AddSocketDataProvider(&socket_data);
+  socket_data.StopAfter(1);
+
+  MockRead reads2[] = {
+      MockRead(ASYNC, 0, 0)  // EOF
+  };
+  DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
+  socket_factory_.AddSocketDataProvider(&socket_data2);
+  socket_data2.StopAfter(1);
+
+  crypto_client_stream_factory_.set_handshake_mode(
+      MockCryptoClientStream::ZERO_RTT);
+  host_resolver_.set_synchronous_mode(true);
+  host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
+                                           "192.168.0.1", "");
+
+  QuicStreamRequest request(&factory_);
+  QuicServerId server_id(host_port_pair_, is_https_, privacy_mode_);
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_pair_, is_https_, privacy_mode_, "GET",
+                            net_log_, callback_.callback()));
+  EXPECT_EQ(2u,
+            QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
+
+  runner_->RunNextTask();
+
+  scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
+  EXPECT_TRUE(stream.get());
+  EXPECT_TRUE(socket_data.at_read_eof());
+  EXPECT_TRUE(socket_data.at_write_eof());
+  EXPECT_EQ(0u,
+            QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
+}
+
 }  // namespace test
 }  // namespace net