Add and persist a new field in AlternativeServiceInfo to list QUIC verisons advertised

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>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/mock_network_change_notifier.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_proxy_delegate.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/dns/mock_host_resolver.h"
@@ skipping 93 matching lines @@
         break;
     }
     os << " }";
     return os;
   }
 
   QuicVersion version;
   DestinationType destination_type;
 };
 
+std::string GenerateQuicVersionsListForAltSvcHeader(
+    const QuicVersionVector& versions) {
+  std::string result = "";
+  for (const QuicVersion& version : versions) {
+    if (!result.empty())
+      result.append(",");
+    result.append(base::IntToString(version));
+  }
+  return result;
+}
+
 std::vector<PoolingTestParams> GetPoolingTestParams() {
   std::vector<PoolingTestParams> params;
   QuicVersionVector all_supported_versions = AllSupportedVersions();
   for (const QuicVersion version : all_supported_versions) {
     params.push_back(PoolingTestParams{version, SAME_AS_FIRST});
     params.push_back(PoolingTestParams{version, SAME_AS_SECOND});
     params.push_back(PoolingTestParams{version, DIFFERENT});
   }
   return params;
 }
@@ skipping 352 matching lines @@
       QuicStreamId stream_id,
       bool should_include_version,
       bool fin,
       SpdyHeaderBlock headers,
       QuicStreamOffset* offset) {
     return server_maker_.MakeResponseHeadersPacketWithOffsetTracking(
         packet_number, stream_id, should_include_version, fin,
         std::move(headers), offset);
   }
 
-  void CreateSession() {
+  void CreateSession(const QuicVersionVector& supported_versions) {
     session_params_.enable_quic = true;
-    session_params_.quic_supported_versions = SupportedVersions(version_);
+    session_params_.quic_supported_versions = supported_versions;
 
     session_context_.quic_clock = &clock_;
     session_context_.quic_random = &random_generator_;
     session_context_.client_socket_factory = &socket_factory_;
     session_context_.quic_crypto_client_stream_factory =
         &crypto_client_stream_factory_;
     session_context_.host_resolver = &host_resolver_;
     session_context_.cert_verifier = &cert_verifier_;
     session_context_.transport_security_state = &transport_security_state_;
     session_context_.cert_transparency_verifier =
         cert_transparency_verifier_.get();
     session_context_.ct_policy_enforcer = &ct_policy_enforcer_;
     session_context_.socket_performance_watcher_factory =
         &test_socket_performance_watcher_factory_;
     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 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 65 matching lines @@
       uint16_t port) {
     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_.SetAlternativeService(server, alternative_service,
-                                                  expiration);
+    http_server_properties_.SetQuicAlternativeService(
+        server, alternative_service, expiration,
+        HttpNetworkSession::Params().quic_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_.SetAlternativeService(server, alternative_service,
-                                                  expiration);
+    http_server_properties_.SetQuicAlternativeService(
+        server, alternative_service, expiration,
+        HttpNetworkSession::Params().quic_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 542 matching lines @@
 // HttpNetworkTransaction should reset the request and retry without using
 // 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_.SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties_.SetQuicAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_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 239 matching lines @@
   EXPECT_EQ(
       2u,
       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) {
+  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)};
+
+  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
+                                     0);
+  socket_factory_.AddSocketDataProvider(&http_data);
+  socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
+
+  MockQuicData mock_quic_data;
+  QuicStreamOffset header_stream_offset = 0;
+  mock_quic_data.AddWrite(
+      ConstructInitialSettingsPacket(1, &header_stream_offset));
+  mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
+      2, GetNthClientInitiatedStreamId(0), true, true,
+      GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
+  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
+      1, GetNthClientInitiatedStreamId(0), false, false,
+      GetResponseHeaders("200 OK")));
+  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);
+
+  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],
+            alt_svc_info_vector[0].advertised_versions()[0]);
+  EXPECT_EQ(current_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),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
@@ skipping 1309 matching lines @@
   mock_quic_data2.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
   mock_quic_data2.AddRead(ASYNC, 0);               // EOF
 
   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_.SetAlternativeService(
+  http_server_properties_.SetQuicAlternativeService(
       url::SchemeHostPort(origin1),
-      AlternativeService(kProtoQUIC, "mail.example.com", 443), expiration);
+      AlternativeService(kProtoQUIC, "mail.example.com", 443), expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   // Set up alternative service for |origin2|.
   AlternativeServiceInfoVector alternative_services;
-  http_server_properties_.SetAlternativeService(
+  http_server_properties_.SetQuicAlternativeService(
       url::SchemeHostPort(origin2),
-      AlternativeService(kProtoQUIC, "www.example.com", 443), expiration);
+      AlternativeService(kProtoQUIC, "www.example.com", 443), expiration,
+      HttpNetworkSession::Params().quic_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 202 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_.SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties_.SetQuicAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_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_.SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties_.SetQuicAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_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 42 matching lines @@
   AddHangingNonAlternateProtocolSocketData();
 
   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_.SetAlternativeService(
-      url::SchemeHostPort(origin1), alternative_service1, expiration);
+  http_server_properties_.SetQuicAlternativeService(
+      url::SchemeHostPort(origin1), alternative_service1, expiration,
+      HttpNetworkSession::Params().quic_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(alternative_service2, expiration));
+      AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+          alternative_service2, expiration,
+          session_->params().quic_supported_versions));
   alternative_services.push_back(
-      AlternativeServiceInfo(alternative_service1, expiration));
+      AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+          alternative_service1, expiration,
+          session_->params().quic_supported_versions));
   http_server_properties_.SetAlternativeServices(url::SchemeHostPort(origin2),
                                                  alternative_services);
   // 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.
   request_.url = origin2;
 
@@ skipping 1540 matching lines @@
   void TearDown() override {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     // Empty the current queue.
     base::RunLoop().RunUntilIdle();
     PlatformTest::TearDown();
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::RunLoop().RunUntilIdle();
     session_.reset();
   }
 
-  void SetAlternativeService(const std::string& origin) {
+  void SetQuicAlternativeService(const std::string& origin) {
     HostPortPair destination;
     switch (destination_type_) {
       case SAME_AS_FIRST:
         destination = HostPortPair(origin1_, 443);
         break;
       case SAME_AS_SECOND:
         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_.SetAlternativeService(
+    http_server_properties_.SetQuicAlternativeService(
         url::SchemeHostPort("https", origin, 443), alternative_service,
-        expiration);
+        expiration, session_->params().quic_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 150 matching lines @@
   if (destination_type_ == DIFFERENT)
     return;
 
   GURL url("https://mail.example.com/");
   origin1_ = url.host();
 
   // Not used for requests, but this provides a test case where the certificate
   // is valid for the hostname of the alternative service.
   origin2_ = "mail.example.org";
 
-  SetAlternativeService(origin1_);
+  SetQuicAlternativeService(origin1_);
 
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
   ASSERT_FALSE(cert->VerifyNameMatch(origin1_, false));
   ASSERT_TRUE(cert->VerifyNameMatch(origin2_, false));
 
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   verify_details.cert_verify_result.is_issued_by_known_root = true;
   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(AllDataConsumed());
 }
 
 // First request opens QUIC session to alternative service.  Second request
 // pools to it, because destination matches and certificate is valid, even
 // though QuicServerId is different.
 TEST_P(QuicNetworkTransactionWithDestinationTest, PoolIfCertificateValid) {
   origin1_ = "mail.example.org";
   origin2_ = "news.example.org";
 
-  SetAlternativeService(origin1_);
-  SetAlternativeService(origin2_);
+  SetQuicAlternativeService(origin1_);
+  SetQuicAlternativeService(origin2_);
 
   scoped_refptr<X509Certificate> cert(
       ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
   ASSERT_TRUE(cert->VerifyNameMatch(origin1_, false));
   ASSERT_TRUE(cert->VerifyNameMatch(origin2_, false));
   ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname, false));
 
   ProofVerifyDetailsChromium verify_details;
   verify_details.cert_verify_result.verified_cert = cert;
   verify_details.cert_verify_result.is_issued_by_known_root = true;
@@ skipping 50 matching lines @@
 
 // First request opens QUIC session to alternative service.  Second request does
 // not pool to it, even though destination matches, because certificate is not
 // valid.  Instead, a new QUIC session is opened to the same destination with a
 // different QuicServerId.
 TEST_P(QuicNetworkTransactionWithDestinationTest,
        DoNotPoolIfCertificateInvalid) {
   origin1_ = "news.example.org";
   origin2_ = "mail.example.com";
 
-  SetAlternativeService(origin1_);
-  SetAlternativeService(origin2_);
+  SetQuicAlternativeService(origin1_);
+  SetQuicAlternativeService(origin2_);
 
   scoped_refptr<X509Certificate> cert1(
       ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
   ASSERT_TRUE(cert1->VerifyNameMatch(origin1_, false));
   ASSERT_FALSE(cert1->VerifyNameMatch(origin2_, false));
   ASSERT_FALSE(cert1->VerifyNameMatch(kDifferentHostname, false));
 
   scoped_refptr<X509Certificate> cert2(
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
   ASSERT_TRUE(cert2->VerifyNameMatch(origin2_, false));
@@ skipping 132 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