Change QuicStreamRequest::Request() to take a preferred QuicVersion so that

net/quic/chromium/quic_stream_factory_test.cc

Index: net/quic/chromium/quic_stream_factory_test.cc
diff --git a/net/quic/chromium/quic_stream_factory_test.cc b/net/quic/chromium/quic_stream_factory_test.cc
index d97c7ce302b74965b162bccc097d47178fc17f91..d4ee8028aeec50461b0b685e3b394ad358589a17 100644
--- a/net/quic/chromium/quic_stream_factory_test.cc
+++ b/net/quic/chromium/quic_stream_factory_test.cc
@@ -204,6 +204,8 @@ class QuicStreamFactoryTestBase {
         force_hol_blocking_(false),
         race_cert_verification_(false),
         estimate_initial_rtt_(false) {
+    supported_versions_.push_back(version_);
+    advertised_versions_.push_back(version_);
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
 
@@ -216,7 +218,7 @@ class QuicStreamFactoryTestBase {
         &transport_security_state_, cert_transparency_verifier_.get(),
         /*SocketPerformanceWatcherFactory*/ nullptr,
         &crypto_client_stream_factory_, &random_generator_, &clock_,
-        kDefaultMaxPacketSize, string(), SupportedVersions(version_),
+        kDefaultMaxPacketSize, string(), supported_versions_,
         store_server_configs_in_properties_, close_sessions_on_ip_change_,
         /*mark_quic_broken_when_network_blackholes*/ false,
         idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_,
@@ -285,7 +287,7 @@ class QuicStreamFactoryTestBase {
     QuicStreamRequest request(factory_.get());
     GURL url("https://" + destination.host() + "/");
     EXPECT_EQ(ERR_IO_PENDING,
-              request.Request(destination, privacy_mode_,
+              request.Request(destination, advertised_versions_, privacy_mode_,
                               /*cert_verify_flags=*/0, url, "GET", net_log_,
                               callback_.callback()));
 
@@ -429,10 +431,11 @@ class QuicStreamFactoryTestBase {
 
     // Create request and QuicHttpStream.
     QuicStreamRequest request(factory_.get());
-    EXPECT_EQ(ERR_IO_PENDING,
-              request.Request(host_port_pair_, privacy_mode_,
-                              /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                              callback_.callback()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                        /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                        callback_.callback()));
     EXPECT_EQ(OK, callback_.WaitForResult());
 
     // Run QuicChromiumClientSession::WriteToNewSocket()
@@ -610,7 +613,8 @@ class QuicStreamFactoryTestBase {
 
     QuicStreamRequest request(factory_.get());
     EXPECT_EQ(ERR_IO_PENDING,
-              request.Request(quic_server_id.host_port_pair(), privacy_mode_,
+              request.Request(quic_server_id.host_port_pair(),
+                              advertised_versions_, privacy_mode_,
                               /*cert_verify_flags=*/0, url_, "GET", net_log_,
                               callback_.callback()));
     EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -643,7 +647,8 @@ class QuicStreamFactoryTestBase {
 
     QuicStreamRequest request2(factory_.get());
     EXPECT_EQ(ERR_IO_PENDING,
-              request2.Request(quic_server_id2.host_port_pair(), privacy_mode_,
+              request2.Request(quic_server_id2.host_port_pair(),
+                               advertised_versions_, privacy_mode_,
                                /*cert_verify_flags=*/0,
                                GURL("https://mail.example.org/"), "GET",
                                net_log_, callback_.callback()));
@@ -703,6 +708,8 @@ class QuicStreamFactoryTestBase {
   MockClock clock_;
   scoped_refptr<TestTaskRunner> runner_;
   QuicVersion version_;
+  QuicVersionVector supported_versions_;
+  QuicVersionVector advertised_versions_;
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
   HttpServerPropertiesImpl http_server_properties_;
@@ -759,19 +766,21 @@ TEST_P(QuicStreamFactoryTest, Create) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_,
-                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                 callback_.callback()));
+  EXPECT_EQ(
+      OK, request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                           /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                           callback_.callback()));
   // Will reset stream 3.
   stream = request2.CreateStream();
 
@@ -780,9 +789,10 @@ TEST_P(QuicStreamFactoryTest, Create) {
   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
   // in streams on different sessions.
   QuicStreamRequest request3(factory_.get());
-  EXPECT_EQ(OK, request3.Request(host_port_pair_, privacy_mode_,
-                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                 callback_.callback()));
+  EXPECT_EQ(
+      OK, request3.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                           /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                           callback_.callback()));
   stream = request3.CreateStream();   // Will reset stream 5.
   stream.reset();                     // Will reset stream 7.
 
@@ -806,9 +816,10 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
 
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -832,9 +843,10 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "POST", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "POST", net_log_,
+                          callback_.callback()));
 
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -842,7 +854,13 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
-TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) {
+TEST_P(QuicStreamFactoryTest, CreateWithNoAdvertisedVersion) {
+  // Set the net stack to support two QUIC versions.
+  if (version_ != QUIC_VERSION_40) {
+    supported_versions_.push_back(QUIC_VERSION_40);
+  } else {
+    supported_versions_.push_back(QUIC_VERSION_38);
+  }
   Initialize();
   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
@@ -853,8 +871,11 @@ TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
+  // There is no advertised QUIC version. QuicStreamFactory::Request will use
+  // the preferred QUIC version that is suppported by the net stack,
+  // i.e., |version_|.
   EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
+            request.Request(host_port_pair_, QuicVersionVector(), privacy_mode_,
                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
                             callback_.callback()));
 
@@ -862,6 +883,112 @@ TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) {
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
 
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_EQ(version_, session->GetQuicVersion());
+  EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us);
+  ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend());
+}
+
+TEST_P(QuicStreamFactoryTest, CreateWithNoMutuallySupportedVersions) {
+  // Set the net stack to support two QUIC versions.
+  if (version_ != QUIC_VERSION_40) {
+    supported_versions_.push_back(QUIC_VERSION_40);
+  } else {
+    supported_versions_.push_back(QUIC_VERSION_38);
+  }
+  // Set the advertised versions to be different from all the versions that
+  // this net stack supports. QuicStreamFactory::Request should use the
+  // preferred QUIC version supported by the net stack.
+  advertised_versions_.clear();
+  advertised_versions_.push_back(QUIC_VERSION_UNSUPPORTED);
+
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  MockQuicData socket_data;
+  socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+  socket_data.AddWrite(ConstructInitialSettingsPacket());
+  socket_data.AddSocketDataToFactory(&socket_factory_);
+
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
+
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
+  std::unique_ptr<HttpStream> stream = request.CreateStream();
+  EXPECT_TRUE(stream.get());
+
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_EQ(version_, session->GetQuicVersion());
+  EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us);
+  ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend());
+}
+
+TEST_P(QuicStreamFactoryTest, CreateWithMutuallySupportedVersions) {
+  // Set the net stack to support two QUIC versions: |version_| is the
+  // non-preferred version.
+  supported_versions_.clear();
+  if (version_ != QUIC_VERSION_40) {
+    supported_versions_.push_back(QUIC_VERSION_40);
+  } else {
+    supported_versions_.push_back(QUIC_VERSION_38);
+  }
+  supported_versions_.push_back(version_);
+
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  MockQuicData socket_data;
+  socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+  socket_data.AddWrite(ConstructInitialSettingsPacket());
+  socket_data.AddSocketDataToFactory(&socket_factory_);
+
+  QuicStreamRequest request(factory_.get());
+  // The version advertised {version_} is not preferred by the net stack but
+  // supportd. QuicStreamFactory::Request should select the mutually supported

[Bence, 2017/06/28 19:08:58]

s/supportd/supported/

[Zhongyi Shi, 2017/07/05 23:08:59]

Acknowledged.

+  // version.
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
+
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
+  std::unique_ptr<HttpStream> stream = request.CreateStream();
+  EXPECT_TRUE(stream.get());
+
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_EQ(version_, session->GetQuicVersion());
+  EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us);
+  ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend());
+}
+
+TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) {
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  MockQuicData socket_data;
+  socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+  socket_data.AddWrite(ConstructInitialSettingsPacket());
+  socket_data.AddSocketDataToFactory(&socket_factory_);
+
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
+
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
+  std::unique_ptr<HttpStream> stream = request.CreateStream();
+  EXPECT_TRUE(stream.get());
+
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
   EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us);
   ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend());
@@ -884,10 +1011,11 @@ TEST_P(QuicStreamFactoryTest, CachedInitialRtt) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -915,10 +1043,11 @@ TEST_P(QuicStreamFactoryTest, 2gInitialRtt) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -946,10 +1075,11 @@ TEST_P(QuicStreamFactoryTest, 3gInitialRtt) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -972,10 +1102,11 @@ TEST_P(QuicStreamFactoryTest, GoAway) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1002,10 +1133,11 @@ TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1047,15 +1179,16 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
@@ -1105,7 +1238,7 @@ TEST_P(QuicStreamFactoryTest, PoolingWithServerMigration) {
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(server2, privacy_mode_,
+            request2.Request(server2, advertised_versions_, privacy_mode_,
                              /*cert_verify_flags=*/0, url2_, "GET", net_log_,
                              callback.callback()));
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -1139,15 +1272,16 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
@@ -1159,7 +1293,7 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(factory_.get());
-  EXPECT_EQ(OK, request3.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request3.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback3.callback()));
   std::unique_ptr<HttpStream> stream3 = request3.CreateStream();
@@ -1192,7 +1326,7 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
+  EXPECT_EQ(OK, request.Request(server1, advertised_versions_, privacy_mode_,
                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1200,7 +1334,7 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
@@ -1236,7 +1370,7 @@ TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
+  EXPECT_EQ(OK, request.Request(server1, advertised_versions_, privacy_mode_,
                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1244,7 +1378,7 @@ TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
@@ -1291,7 +1425,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
+  EXPECT_EQ(OK, request.Request(server1, advertised_versions_, privacy_mode_,
                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1299,7 +1433,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
@@ -1329,10 +1463,11 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1349,10 +1484,11 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   // Create a new request for the same destination and verify that a
   // new session is created.
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -1392,9 +1528,9 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   // kDefaultMaxStreamsPerConnection / 2.
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) {
     QuicStreamRequest request(factory_.get());
-    int rv = request.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback());
+    int rv = request.Request(
+        host_port_pair_, advertised_versions_, privacy_mode_,
+        /*cert_verify_flags=*/0, url_, "GET", net_log_, callback_.callback());
     if (i == 0) {
       EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
       EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -1409,9 +1545,10 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   }
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                CompletionCallback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          CompletionCallback()));
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream);
   EXPECT_EQ(ERR_IO_PENDING,
@@ -1443,10 +1580,11 @@ TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
 
@@ -1462,10 +1600,11 @@ TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE));
 
@@ -1481,18 +1620,20 @@ TEST_P(QuicStreamFactoryTest, CancelCreate) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
   {
     QuicStreamRequest request(factory_.get());
-    EXPECT_EQ(ERR_IO_PENDING,
-              request.Request(host_port_pair_, privacy_mode_,
-                              /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                              callback_.callback()));
+    EXPECT_EQ(
+        ERR_IO_PENDING,
+        request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                        /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                        callback_.callback()));
   }
 
   base::RunLoop().RunUntilIdle();
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_,
-                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                 callback_.callback()));
+  EXPECT_EQ(
+      OK, request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                           /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                           callback_.callback()));
   std::unique_ptr<HttpStream> stream = request2.CreateStream();
 
   EXPECT_TRUE(stream.get());
@@ -1520,10 +1661,11 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1540,10 +1682,11 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   // a new session.
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   stream = request2.CreateStream();
@@ -1574,10 +1717,11 @@ TEST_P(QuicStreamFactoryTest,
 
   // Create request, should fail after the write of the CHLO fails.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
   EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
@@ -1593,10 +1737,11 @@ TEST_P(QuicStreamFactoryTest,
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
   EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
   // Run the message loop to complete host resolution.
@@ -1636,10 +1781,11 @@ TEST_P(QuicStreamFactoryTest, WriteErrorInCryptoConnectWithSyncHostResolution) {
 
   // Create request, should fail immediately.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_QUIC_HANDSHAKE_FAILED,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   // Check no active session, or active jobs left for this server.
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
   EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
@@ -1655,10 +1801,11 @@ TEST_P(QuicStreamFactoryTest, WriteErrorInCryptoConnectWithSyncHostResolution) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
   EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
 
@@ -1698,10 +1845,11 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -1719,10 +1867,11 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
   // a new session.
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   stream = request2.CreateStream();
@@ -1766,10 +1915,11 @@ void QuicStreamFactoryTestBase::OnNetworkMadeDefault(bool async_write_before) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -1833,10 +1983,11 @@ void QuicStreamFactoryTestBase::OnNetworkMadeDefault(bool async_write_before) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -1896,10 +2047,11 @@ void QuicStreamFactoryTestBase::OnNetworkDisconnected(bool async_write_before) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -1958,10 +2110,11 @@ void QuicStreamFactoryTestBase::OnNetworkDisconnected(bool async_write_before) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -2006,10 +2159,11 @@ void QuicStreamFactoryTestBase::OnNetworkDisconnectedWithNetworkList(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2064,10 +2218,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkMadeDefaultNonMigratableStream) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2113,10 +2268,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkMadeDefaultConnectionMigrationDisabled) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2165,10 +2321,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkDisconnectedNonMigratableStream) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2213,10 +2370,11 @@ TEST_P(QuicStreamFactoryTest,
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2261,10 +2419,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkMadeDefaultNoOpenStreams) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2299,10 +2458,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkDisconnectedNoOpenStreams) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2341,10 +2501,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkChangeDisconnectedPauseBeforeConnected) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2417,10 +2578,11 @@ TEST_P(QuicStreamFactoryTest, OnNetworkChangeDisconnectedPauseBeforeConnected) {
   socket_data2.AddWrite(ConstructInitialSettingsPacket());
   socket_data2.AddSocketDataToFactory(&socket_factory_);
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -2466,7 +2628,7 @@ TEST_P(QuicStreamFactoryTest,
 
   // Create request and QuicHttpStream to create session1.
   QuicStreamRequest request1(factory_.get());
-  EXPECT_EQ(OK, request1.Request(server1, privacy_mode_,
+  EXPECT_EQ(OK, request1.Request(server1, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url_, "GET", net_log_,
                                  callback_.callback()));
   std::unique_ptr<HttpStream> stream1 = request1.CreateStream();
@@ -2474,7 +2636,7 @@ TEST_P(QuicStreamFactoryTest,
 
   // Create request and QuicHttpStream to create session2.
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
@@ -2558,10 +2720,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarly) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2622,10 +2785,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarly) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -2683,10 +2847,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyWithAsyncWrites) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2749,10 +2914,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyWithAsyncWrites) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -2802,10 +2968,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyNoNewNetwork) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2854,10 +3021,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyNonMigratableStream) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2906,10 +3074,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyConnectionMigrationDisabled) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -2964,10 +3133,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteError(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3053,10 +3223,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorNoNewNetwork(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3142,10 +3313,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorNonMigratableStream(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3206,10 +3378,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMigrationDisabled(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3285,10 +3458,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnMultipleWriteErrors(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3365,10 +3539,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorWithNotificationQueued(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3463,10 +3638,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnNotificationWithWriteErrorQueued(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3562,10 +3738,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorPauseBeforeConnected(
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3643,10 +3820,11 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorPauseBeforeConnected(
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -3695,10 +3873,11 @@ void QuicStreamFactoryTestBase::
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3784,10 +3963,11 @@ void QuicStreamFactoryTestBase::
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -3849,10 +4029,11 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyToBadSocket) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -3912,10 +4093,11 @@ TEST_P(QuicStreamFactoryTest, ServerMigration) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -4054,10 +4236,11 @@ TEST_P(QuicStreamFactoryTest, ServerMigrationIPv4ToIPv6Fails) {
 
   // Create request and QuicHttpStream.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
   EXPECT_TRUE(stream.get());
@@ -4108,10 +4291,11 @@ TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -4128,10 +4312,11 @@ TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
   // a new session.
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   stream = request2.CreateStream();
@@ -4161,10 +4346,11 @@ TEST_P(QuicStreamFactoryTest, OnCertDBChanged) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -4182,10 +4368,11 @@ TEST_P(QuicStreamFactoryTest, OnCertDBChanged) {
   // a new session.
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, privacy_mode_,
-                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                       /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                       callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   stream = request2.CreateStream();
@@ -4287,9 +4474,10 @@ TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
                                            "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
 
   // If we are waiting for disk cache, we would have posted a task. Verify that
   // the CancelWaitForDataReady task hasn't been posted.
@@ -4334,9 +4522,10 @@ TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) {
   EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
             QuicStreamFactoryPeer::GetPingTimeout(factory_.get()));
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
   EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
@@ -4366,7 +4555,7 @@ TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) {
   DVLOG(1) << "Create 2nd session and timeout with open stream";
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
+  EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_,
                                  /*cert_verify_flags=*/0, url2_, "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 = GetActiveSession(server2);
@@ -4431,10 +4620,11 @@ TEST_P(QuicStreamFactoryTest, StartCertVerifyJob) {
 
   // Start a QUIC request.
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
 
@@ -4477,9 +4667,10 @@ TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
                                        "StartReading");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
 
   // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
   // called.
@@ -4522,9 +4713,10 @@ TEST_P(QuicStreamFactoryTest, YieldAfterDuration) {
                                        "StartReading");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
-                                /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                callback_.callback()));
+  EXPECT_EQ(
+      OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                          /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                          callback_.callback()));
 
   // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
   // called.
@@ -4553,10 +4745,11 @@ TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -4574,9 +4767,10 @@ TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) {
         ->promised_by_url())[kDefaultUrl] = &promised;
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_,
-                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                 callback_.callback()));
+  EXPECT_EQ(
+      OK, request2.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                           /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                           callback_.callback()));
 
   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
 }
@@ -4600,10 +4794,11 @@ TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) {
   socket_data2.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream = request.CreateStream();
@@ -4627,7 +4822,8 @@ TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) {
   // cancel it because the privacy modes do not match.
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(host_port_pair_, PRIVACY_MODE_ENABLED,
+            request2.Request(host_port_pair_, advertised_versions_,
+                             PRIVACY_MODE_ENABLED,
                              /*cert_verify_flags=*/0, url_, "GET", net_log_,
                              callback_.callback()));
 
@@ -4662,7 +4858,7 @@ TEST_P(QuicStreamFactoryTest, PoolByOrigin) {
 
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
-            request1.Request(destination1, privacy_mode_,
+            request1.Request(destination1, advertised_versions_, privacy_mode_,
                              /*cert_verify_flags=*/0, url_, "GET", net_log_,
                              callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4673,9 +4869,10 @@ TEST_P(QuicStreamFactoryTest, PoolByOrigin) {
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(destination2, privacy_mode_,
-                                 /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                                 callback2.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(destination2, advertised_versions_, privacy_mode_,
+                             /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                             callback2.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
 
@@ -4704,10 +4901,11 @@ TEST_P(QuicStreamFactoryTest, ForceHolBlockingEnabled) {
   socket_data.AddSocketDataToFactory(&socket_factory_);
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request.Request(host_port_pair_, privacy_mode_,
-                            /*cert_verify_flags=*/0, url_, "GET", net_log_,
-                            callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request.Request(host_port_pair_, advertised_versions_, privacy_mode_,
+                      /*cert_verify_flags=*/0, url_, "GET", net_log_,
+                      callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
 
@@ -4801,9 +4999,10 @@ TEST_P(QuicStreamFactoryWithDestinationTest, InvalidCertificate) {
   AddHangingSocketData();
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(destination, privacy_mode_,
-                                            /*cert_verify_flags=*/0, url, "GET",
-                                            net_log_, callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(destination, advertised_versions_, privacy_mode_,
+                            /*cert_verify_flags=*/0, url, "GET", net_log_,
+                            callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
 
@@ -4844,7 +5043,7 @@ TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) {
 
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
-            request1.Request(destination, privacy_mode_,
+            request1.Request(destination, advertised_versions_, privacy_mode_,
                              /*cert_verify_flags=*/0, url1, "GET", net_log_,
                              callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4856,9 +5055,10 @@ TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) {
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(destination, privacy_mode_,
-                                 /*cert_verify_flags=*/0, url2, "GET", net_log_,
-                                 callback2.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(destination, advertised_versions_, privacy_mode_,
+                             /*cert_verify_flags=*/0, url2, "GET", net_log_,
+                             callback2.callback()));
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
 
@@ -4915,10 +5115,11 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DifferentPrivacyMode) {
   sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1));
 
   QuicStreamRequest request1(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request1.Request(destination, PRIVACY_MODE_DISABLED,
-                             /*cert_verify_flags=*/0, url1, "GET", net_log_,
-                             callback_.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request1.Request(destination, advertised_versions_, PRIVACY_MODE_DISABLED,
+                       /*cert_verify_flags=*/0, url1, "GET", net_log_,
+                       callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   std::unique_ptr<HttpStream> stream1 = request1.CreateStream();
   EXPECT_TRUE(stream1.get());
@@ -4926,10 +5127,11 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DifferentPrivacyMode) {
 
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(destination, PRIVACY_MODE_ENABLED,
-                             /*cert_verify_flags=*/0, url2, "GET", net_log_,
-                             callback2.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      request2.Request(destination, advertised_versions_, PRIVACY_MODE_ENABLED,
+                       /*cert_verify_flags=*/0, url2, "GET", net_log_,
+                       callback2.callback()));
   EXPECT_EQ(OK, callback2.WaitForResult());
   std::unique_ptr<HttpStream> stream2 = request2.CreateStream();
   EXPECT_TRUE(stream2.get());
@@ -4999,7 +5201,7 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DisjointCertificate) {
 
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
-            request1.Request(destination, privacy_mode_,
+            request1.Request(destination, advertised_versions_, privacy_mode_,
                              /*cert_verify_flags=*/0, url1, "GET", net_log_,
                              callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -5010,7 +5212,7 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DisjointCertificate) {
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
-            request2.Request(destination, privacy_mode_,
+            request2.Request(destination, advertised_versions_, privacy_mode_,
                              /*cert_verify_flags=*/0, url2, "GET", net_log_,
                              callback2.callback()));
   EXPECT_THAT(callback2.WaitForResult(), IsOk());