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

net/http/http_stream_factory_impl_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 "net/http/http_stream_factory_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 1091 matching lines @@
       EXPECT_EQ(static_cast<int>(i + 1),
                 test_proxy_delegate.get_alternative_proxy_invocations());
     }
   }
 }
 
 TEST_F(HttpStreamFactoryTest, UsePreConnectIfNoZeroRTT) {
   for (int num_streams = 1; num_streams < 3; ++num_streams) {
     GURL url = GURL("https://www.google.com");
 
-    // Set up QUIC as alternative_service.
-    HttpServerPropertiesImpl http_server_properties;
-    const AlternativeService alternative_service(kProtoQUIC, url.host().c_str(),
-                                                 url.IntPort());
-    AlternativeServiceInfoVector alternative_service_info_vector;
-    base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-    alternative_service_info_vector.push_back(
-        AlternativeServiceInfo(alternative_service, expiration));
-    HostPortPair host_port_pair(alternative_service.host_port_pair());
-    url::SchemeHostPort server("https", host_port_pair.host(),
-                               host_port_pair.port());
-    http_server_properties.SetAlternativeServices(
-        server, alternative_service_info_vector);
-
     SpdySessionDependencies session_deps(
         ProxyService::CreateFixed("http_proxy"));
 
     // Setup params to disable preconnect, but QUIC doesn't 0RTT.
     HttpNetworkSession::Params session_params =
         SpdySessionDependencies::CreateSessionParams(&session_deps);
     session_params.enable_quic = true;
 
+    // Set up QUIC as alternative_service.
+    HttpServerPropertiesImpl http_server_properties;
+    const AlternativeService alternative_service(kProtoQUIC, url.host().c_str(),
+                                                 url.IntPort());
+    base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
+    HostPortPair host_port_pair(alternative_service.host_port_pair());
+    url::SchemeHostPort server("https", host_port_pair.host(),
+                               host_port_pair.port());
+    http_server_properties.SetQuicAlternativeService(
+        server, alternative_service, expiration,
+        session_params.quic_supported_versions);
+
     HttpNetworkSession::Context session_context =
         SpdySessionDependencies::CreateSessionContext(&session_deps);
     session_context.http_server_properties = &http_server_properties;
 
     auto session =
         base::MakeUnique<HttpNetworkSession>(session_params, session_context);
     HttpNetworkSessionPeer peer(session.get());
     HostPortPair proxy_host("http_proxy", 80);
     CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
         new CapturePreconnectsHttpProxySocketPool(
@@ skipping 1121 matching lines @@
     session_context.proxy_service = proxy_service_.get();
     session_context.ssl_config_service = ssl_config_service_.get();
     session_context.client_socket_factory = &socket_factory_;
     session_.reset(new HttpNetworkSession(params_, session_context));
     session_->quic_stream_factory()->set_require_confirmation(false);
   }
 
   void AddQuicAlternativeService() {
     const AlternativeService alternative_service(kProtoQUIC, "www.example.org",
                                                  443);
-    AlternativeServiceInfoVector alternative_service_info_vector;
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-    alternative_service_info_vector.push_back(
-        AlternativeServiceInfo(alternative_service, expiration));
-    http_server_properties_.SetAlternativeServices(
-        url::SchemeHostPort(default_url_), alternative_service_info_vector);
+    http_server_properties_.SetQuicAlternativeService(
+        url::SchemeHostPort(default_url_), alternative_service, expiration,
+        session_->params().quic_supported_versions);
   }
 
   test::QuicTestPacketMaker& client_packet_maker() {
     return client_packet_maker_;
   }
   test::QuicTestPacketMaker& server_packet_maker() {
     return server_packet_maker_;
   }
 
   MockClientSocketFactory& socket_factory() { return socket_factory_; }
@@ skipping 54 matching lines @@
 
   // Add hanging data for http job.
   auto hanging_data = base::MakeUnique<StaticSocketDataProvider>();
   MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
   hanging_data->set_connect_data(hanging_connect);
   socket_factory().AddSocketDataProvider(hanging_data.get());
   SSLSocketDataProvider ssl_data(ASYNC, OK);
   socket_factory().AddSSLSocketDataProvider(&ssl_data);
 
   // Set up QUIC as alternative_service.
+  Initialize();
   AddQuicAlternativeService();
-  Initialize();
 
   // Now request a stream.
   SSLConfig ssl_config;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = default_url_;
   request_info.load_flags = 0;
 
   StreamRequestWaiter waiter;
   std::unique_ptr<HttpStreamRequest> request(
@@ skipping 42 matching lines @@
        RequestBidirectionalStreamImplQuicNotEnabled) {
   // Make the http job fail.
   auto http_job_data = base::MakeUnique<StaticSocketDataProvider>();
   MockConnect failed_connect(ASYNC, ERR_CONNECTION_REFUSED);
   http_job_data->set_connect_data(failed_connect);
   socket_factory().AddSocketDataProvider(http_job_data.get());
   SSLSocketDataProvider ssl_data(ASYNC, OK);
   socket_factory().AddSSLSocketDataProvider(&ssl_data);
 
   // Set up QUIC as alternative_service.
-  AddQuicAlternativeService();
   DisableQuicBidirectionalStream();
   Initialize();
+  AddQuicAlternativeService();
 
   // Now request a stream.
   SSLConfig ssl_config;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = default_url_;
   request_info.load_flags = 0;
 
   StreamRequestWaiter waiter;
   std::unique_ptr<HttpStreamRequest> request(
@@ skipping 39 matching lines @@
 
   // Make the http job fail.
   auto http_job_data = base::MakeUnique<StaticSocketDataProvider>();
   MockConnect failed_connect(ASYNC, ERR_CONNECTION_REFUSED);
   http_job_data->set_connect_data(failed_connect);
   socket_factory().AddSocketDataProvider(http_job_data.get());
   SSLSocketDataProvider ssl_data(ASYNC, OK);
   socket_factory().AddSSLSocketDataProvider(&ssl_data);
 
   // Set up QUIC as alternative_service.
+  Initialize();
   AddQuicAlternativeService();
-  Initialize();
 
   // Now request a stream.
   SSLConfig ssl_config;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = default_url_;
   request_info.load_flags = 0;
 
   StreamRequestWaiter waiter;
   std::unique_ptr<HttpStreamRequest> request(
@@ skipping 81 matching lines @@
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 }
 
 }  // namespace
 
 }  // namespace net