Fix QuicNetworkTransaction*Tests to set QuicAlternativeService with

net/quic/chromium/quic_network_transaction_unittest.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 <algorithm>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 221 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcherFactory);
 };
 
 class QuicNetworkTransactionTest
     : public PlatformTest,
       public ::testing::WithParamInterface<QuicVersion> {
  protected:
   QuicNetworkTransactionTest()
       : version_(GetParam()),
+        supported_versions_(SupportedVersions(version_)),
         client_maker_(version_,
                       0,
                       &clock_,
                       kDefaultServerHostName,
                       Perspective::IS_CLIENT),
         server_maker_(version_,
                       0,
                       &clock_,
                       kDefaultServerHostName,
                       Perspective::IS_SERVER),
@@ skipping 279 matching lines @@
     session_context_.proxy_service = proxy_service_.get();
     session_context_.ssl_config_service = ssl_config_service_.get();
     session_context_.http_auth_handler_factory = auth_handler_factory_.get();
     session_context_.http_server_properties = &http_server_properties_;
     session_context_.net_log = net_log_.bound().net_log();
 
     session_.reset(new HttpNetworkSession(session_params_, session_context_));
     session_->quic_stream_factory()->set_require_confirmation(false);
   }
 
-  void CreateSession() { return CreateSession(SupportedVersions(version_)); }
+  void CreateSession() { return CreateSession(supported_versions_); }
 
   void CheckWasQuicResponse(HttpNetworkTransaction* trans) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != nullptr);
     ASSERT_TRUE(response->headers.get() != nullptr);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_alpn_negotiated);
     EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_),
               response->connection_info);
@@ skipping 67 matching lines @@
     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port);
   }
 
   void AddQuicAlternateProtocolMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     url::SchemeHostPort server(request_.url);
     AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties_.SetQuicAlternativeService(
-        server, alternative_service, expiration,
-        HttpNetworkSession::Params().quic_supported_versions);
+        server, alternative_service, expiration, supported_versions_);
   }
 
   void AddQuicRemoteAlternativeServiceMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode,
       const HostPortPair& alternative) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     url::SchemeHostPort server(request_.url);
     AlternativeService alternative_service(kProtoQUIC, alternative.host(),
                                            alternative.port());
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties_.SetQuicAlternativeService(
-        server, alternative_service, expiration,
-        HttpNetworkSession::Params().quic_supported_versions);
+        server, alternative_service, expiration, supported_versions_);
   }
 
   void ExpectBrokenAlternateProtocolMapping() {
     const url::SchemeHostPort server(request_.url);
     const AlternativeServiceInfoVector alternative_service_info_vector =
         http_server_properties_.GetAlternativeServiceInfos(server);
     EXPECT_EQ(1u, alternative_service_info_vector.size());
     EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
         alternative_service_info_vector[0].alternative_service()));
   }
@@ skipping 87 matching lines @@
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return test::GetNthClientInitiatedStreamId(version_, n);
   }
 
   QuicStreamId GetNthServerInitiatedStreamId(int n) {
     return test::GetNthServerInitiatedStreamId(version_, n);
   }
 
   const QuicVersion version_;
+  QuicVersionVector supported_versions_;
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   MockClock clock_;
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
   std::unique_ptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   ProofVerifyDetailsChromium verify_details_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
@@ skipping 436 matching lines @@
 // alternative services.
 TEST_P(QuicNetworkTransactionTest, RetryMisdirectedRequest) {
   // Set up alternative service to use QUIC.
   // Note that |origins_to_force_quic_on| cannot be used in this test, because
   // that overrides |enable_alternative_services|.
   url::SchemeHostPort server(request_.url);
   AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName,
                                          443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties_.SetQuicAlternativeService(
-      server, alternative_service, expiration,
-      HttpNetworkSession::Params().quic_supported_versions);
+      server, alternative_service, expiration, supported_versions_);
 
   // First try: The alternative job uses QUIC and reports an HTTP 421
   // Misdirected Request error.  The main job uses TCP, but |http_data| below is
   // paused at Connect(), so it will never exit the socket pool. This ensures
   // that the alternate job always wins the race and keeps whether the
   // |http_data| exits the socket pool before the main job is aborted
   // deterministic. The first main job gets aborted without the socket pool ever
   // dispensing the socket, making it available for the second try.
   MockQuicData mock_quic_data;
   QuicStreamOffset request_header_offset = 0;
@@ skipping 241 matching lines @@
       http_server_properties->GetAlternativeServiceInfos(https_server).size());
 
   // Send http request to the same origin but with diffrent scheme, should not
   // use QUIC.
   request_.url = GURL("http://mail.example.org:443");
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest,
        StoreMutuallySupportedVersionsWhenProcessAltSvc) {
+  // Add support for another QUIC version besides |version_|.
+  for (const QuicVersion& version : AllSupportedVersions()) {
+    if (version == version_)
+      continue;
+    supported_versions_.push_back(version);
+    break;
+  }
+
   std::string advertised_versions_list_str =
       GenerateQuicVersionsListForAltSvcHeader(AllSupportedVersions());
   std::string altsvc_header =
       base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n",
                          advertised_versions_list_str.c_str());
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
@@ skipping 16 matching lines @@
   mock_quic_data.AddRead(ConstructServerDataPacket(
       2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data.AddRead(ASYNC, 0);               // EOF
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
 
-  // Generate a list of QUIC versions suppored by netstack.
-  QuicVersionVector current_supported_versions = SupportedVersions(version_);
-  if (version_ != QUIC_VERSION_40) {
-    current_supported_versions.push_back(QUIC_VERSION_40);
-  } else {
-    current_supported_versions.push_back(QUIC_VERSION_37);
-  }
-
-  CreateSession(current_supported_versions);
+  CreateSession(supported_versions_);
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 
   // Check alternative service is set with only mutually supported versions.
   const url::SchemeHostPort https_server(request_.url);
   const AlternativeServiceInfoVector alt_svc_info_vector =
       session_->http_server_properties()->GetAlternativeServiceInfos(
           https_server);
   EXPECT_EQ(1u, alt_svc_info_vector.size());
   EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol);
   EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size());
   // Advertised versions will be lised in a sorted order.
-  std::sort(current_supported_versions.begin(),
-            current_supported_versions.end());
-  EXPECT_EQ(current_supported_versions[0],
+  std::sort(supported_versions_.begin(), supported_versions_.end());
+  EXPECT_EQ(supported_versions_[0],
             alt_svc_info_vector[0].advertised_versions()[0]);
-  EXPECT_EQ(current_supported_versions[1],
+  EXPECT_EQ(supported_versions_[1],
             alt_svc_info_vector[0].advertised_versions()[1]);
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) {
   std::string altsvc_header =
       base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_);
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
@@ skipping 1315 matching lines @@
 
   mock_quic_data2.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
 
   // Set up alternative service for |origin1|.
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties_.SetQuicAlternativeService(
       url::SchemeHostPort(origin1),
       AlternativeService(kProtoQUIC, "mail.example.com", 443), expiration,
-      HttpNetworkSession::Params().quic_supported_versions);
+      supported_versions_);
 
   // Set up alternative service for |origin2|.
   AlternativeServiceInfoVector alternative_services;
   http_server_properties_.SetQuicAlternativeService(
       url::SchemeHostPort(origin2),
       AlternativeService(kProtoQUIC, "www.example.com", 443), expiration,
-      HttpNetworkSession::Params().quic_supported_versions);
+      supported_versions_);
   // First request opens connection to |destination1|
   // with QuicServerId.host() == origin1.host().
   SendRequestAndExpectQuicResponse("hello!");
 
   // Second request pools to existing connection with same destination,
   // because certificate matches, even though QuicServerId is different.
   // After it is reset, it will fail back to QUIC and mark QUIC as broken.
   request_.url = origin2;
   SendRequestAndExpectHttpResponse("hello world");
 
@@ skipping 203 matching lines @@
   CreateSession();
 
   const char destination1[] = "first.example.com";
   const char destination2[] = "second.example.com";
 
   // Set up alternative service entry to destination1.
   url::SchemeHostPort server(request_.url);
   AlternativeService alternative_service(kProtoQUIC, destination1, 443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties_.SetQuicAlternativeService(
-      server, alternative_service, expiration,
-      HttpNetworkSession::Params().quic_supported_versions);
+      server, alternative_service, expiration, supported_versions_);
   // First request opens connection to |destination1|
   // with QuicServerId.host() == kDefaultServerHostName.
   SendRequestAndExpectQuicResponse("hello!");
 
   // Set up alternative service entry to a different destination.
   alternative_service = AlternativeService(kProtoQUIC, destination2, 443);
   http_server_properties_.SetQuicAlternativeService(
-      server, alternative_service, expiration,
-      HttpNetworkSession::Params().quic_supported_versions);
+      server, alternative_service, expiration, supported_versions_);
   // Second request pools to existing connection with same QuicServerId,
   // even though alternative service destination is different.
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 // Pool to existing session with matching destination and matching certificate
 // even if origin is different, and even if the alternative service with
 // matching destination is not the first one on the list.
 TEST_P(QuicNetworkTransactionTest, PoolByDestination) {
   GURL origin1 = request_.url;
@@ skipping 44 matching lines @@
   CreateSession();
 
   const char destination1[] = "first.example.com";
   const char destination2[] = "second.example.com";
 
   // Set up alternative service for |origin1|.
   AlternativeService alternative_service1(kProtoQUIC, destination1, 443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties_.SetQuicAlternativeService(
       url::SchemeHostPort(origin1), alternative_service1, expiration,
-      HttpNetworkSession::Params().quic_supported_versions);
+      supported_versions_);
 
   // Set up multiple alternative service entries for |origin2|,
   // the first one with a different destination as for |origin1|,
   // the second one with the same.  The second one should be used,
   // because the request can be pooled to that one.
   AlternativeService alternative_service2(kProtoQUIC, destination2, 443);
   AlternativeServiceInfoVector alternative_services;
   alternative_services.push_back(
       AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
           alternative_service2, expiration,
@@ skipping 1499 matching lines @@
   EXPECT_TRUE(mock_quic_data.AllReadDataConsumed());
   EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed());
 }
 
 class QuicNetworkTransactionWithDestinationTest
     : public PlatformTest,
       public ::testing::WithParamInterface<PoolingTestParams> {
  protected:
   QuicNetworkTransactionWithDestinationTest()
       : version_(GetParam().version),
+        supported_versions_(SupportedVersions(version_)),
         destination_type_(GetParam().destination_type),
         cert_transparency_verifier_(new MultiLogCTVerifier()),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
         random_generator_(0),
         ssl_data_(ASYNC, OK) {}
 
   void SetUp() override {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::RunLoop().RunUntilIdle();
 
     HttpNetworkSession::Params session_params;
     session_params.enable_quic = true;
-    session_params.quic_supported_versions = SupportedVersions(version_);
+    session_params.quic_supported_versions = supported_versions_;
 
     HttpNetworkSession::Context session_context;
 
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
     session_context.quic_clock = &clock_;
 
     crypto_client_stream_factory_.set_handshake_mode(
         MockCryptoClientStream::CONFIRM_HANDSHAKE);
     session_context.quic_crypto_client_stream_factory =
         &crypto_client_stream_factory_;
@@ skipping 37 matching lines @@
         destination = HostPortPair(origin2_, 443);
         break;
       case DIFFERENT:
         destination = HostPortPair(kDifferentHostname, 443);
         break;
     }
     AlternativeService alternative_service(kProtoQUIC, destination);
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties_.SetQuicAlternativeService(
         url::SchemeHostPort("https", origin, 443), alternative_service,
-        expiration, session_->params().quic_supported_versions);
+        expiration, supported_versions_);
   }
 
   std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
       QuicPacketNumber packet_number,
       QuicStreamId stream_id,
       bool should_include_version,
       QuicStreamOffset* offset,
       QuicTestPacketMaker* maker) {
     SpdyPriority priority =
         ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
@@ skipping 110 matching lines @@
               response->connection_info);
     EXPECT_EQ(443, response->socket_address.port());
   }
 
   QuicStreamId GetNthClientInitiatedStreamId(int n) {
     return test::GetNthClientInitiatedStreamId(version_, n);
   }
 
   MockClock clock_;
   QuicVersion version_;
+  QuicVersionVector supported_versions_;
   DestinationType destination_type_;
   std::string origin1_;
   std::string origin2_;
   std::unique_ptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;
   std::unique_ptr<CTVerifier> cert_transparency_verifier_;
   CTPolicyEnforcer ct_policy_enforcer_;
@@ skipping 284 matching lines @@
 
   request_.url = GURL("https://mail.example.org/pushed.jpg");
   ChunkedUploadDataStream upload_data(0);
   upload_data.AppendData("1", 1, true);
   request_.upload_data_stream = &upload_data;
   SendRequestAndExpectQuicResponse("and hello!");
 }
 
 }  // namespace test
 }  // namespace net