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

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 9213 matching lines @@
 std::unique_ptr<HttpNetworkSession> SetupSessionForGroupNameTests(
     SpdySessionDependencies* session_deps_) {
   std::unique_ptr<HttpNetworkSession> session(CreateSession(session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, "", 444);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
       url::SchemeHostPort("https", "host.with.alternate", 443),
-      alternative_service, expiration);
+      alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   return session;
 }
 
 int GroupNameTransactionHelper(const std::string& url,
                                HttpNetworkSession* session) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(url);
 
@@ skipping 942 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, "different.example.org",
                                          444);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
-      url::SchemeHostPort(request.url), alternative_service, expiration);
+      url::SchemeHostPort(request.url), alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
   // Alternative service is not used, request fails.
   EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
 }
 
 // Regression test for https://crbug.com/615497:
@@ skipping 18 matching lines @@
                                        0);
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, "", 444);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
-      url::SchemeHostPort(request.url), alternative_service, expiration);
+      url::SchemeHostPort(request.url), alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
   // Alternative service is not used, request fails.
   EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
 }
 
 TEST_F(HttpNetworkTransactionTest, ClearAlternativeServices) {
   // Set an alternative service for origin.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   url::SchemeHostPort test_server("https", "www.example.org", 443);
   AlternativeService alternative_service(kProtoQUIC, "", 80);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
-      test_server, alternative_service, expiration);
+      test_server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
   EXPECT_EQ(
       1u,
       http_server_properties->GetAlternativeServiceInfos(test_server).size());
 
   // Send a clear header.
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Alt-Svc: clear\r\n"),
       MockRead("\r\n"),
       MockRead("hello world"),
@@ skipping 121 matching lines @@
   StaticSocketDataProvider data_refused;
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
   // Set up a QUIC alternative service for server.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoQUIC, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties->SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties->SetAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
   // Mark the QUIC alternative service as broken.
   http_server_properties->MarkAlternativeServiceBroken(alternative_service);
 
   HttpRequestInfo request;
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   request.method = "GET";
   request.url = GURL(origin_url);
   TestCompletionCallback callback;
   NetErrorDetails details;
   EXPECT_FALSE(details.quic_broken);
@@ skipping 39 matching lines @@
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
 
   // Set up two QUIC alternative services for server.
   AlternativeServiceInfoVector alternative_service_info_vector;
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
 
   AlternativeService alternative_service1(kProtoQUIC, alternative1);
-  AlternativeServiceInfo alternative_service_info1(alternative_service1,
-                                                   expiration);
+  AlternativeServiceInfo alternative_service_info1(
+      alternative_service1, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
   alternative_service_info_vector.push_back(alternative_service_info1);
   AlternativeService alternative_service2(kProtoQUIC, alternative2);
-  AlternativeServiceInfo alternative_service_info2(alternative_service2,
-                                                   expiration);
+  AlternativeServiceInfo alternative_service_info2(
+      alternative_service2, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
   alternative_service_info_vector.push_back(alternative_service_info2);
 
   http_server_properties->SetAlternativeServices(
       server, alternative_service_info_vector);
 
   // Mark one of the QUIC alternative service as broken.
   http_server_properties->MarkAlternativeServiceBroken(alternative_service1);
   EXPECT_EQ(2u,
             http_server_properties->GetAlternativeServiceInfos(server).size());
 
@@ skipping 36 matching lines @@
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const url::SchemeHostPort server(request.url);
   // Port must be < 1024, or the header will be ignored (since initial port was
   // port 80 (another restricted port).
   const AlternativeService alternative_service(
       kProtoHTTP2, "www.example.org",
       666);  // Port is ignored by MockConnect anyway.
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties->SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties->SetAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans.GetResponseInfo();
   ASSERT_TRUE(response);
@@ skipping 43 matching lines @@
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   AlternativeService alternative_service(kProtoHTTP2, "www.example.org",
                                          kUnrestrictedAlternatePort);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
       url::SchemeHostPort(restricted_port_request.url), alternative_service,
-      expiration);
+      expiration, HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&restricted_port_request, callback.callback(),
                        NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Invalid change to unrestricted port should fail.
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_REFUSED));
 }
@@ skipping 29 matching lines @@
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   AlternativeService alternative_service(kProtoHTTP2, "www.example.org",
                                          kUnrestrictedAlternatePort);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
       url::SchemeHostPort(restricted_port_request.url), alternative_service,
-      expiration);
+      expiration, HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&restricted_port_request, callback.callback(),
                         NetLogWithSource()));
   // Change to unrestricted port should succeed.
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
@@ skipping 28 matching lines @@
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
   AlternativeService alternative_service(kProtoHTTP2, "www.example.org",
                                          kRestrictedAlternatePort);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
       url::SchemeHostPort(restricted_port_request.url), alternative_service,
-      expiration);
+      expiration, HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&restricted_port_request, callback.callback(),
                        NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Valid change to restricted port should pass.
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
@@ skipping 28 matching lines @@
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
   AlternativeService alternative_service(kProtoHTTP2, "www.example.org",
                                          kRestrictedAlternatePort);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
       url::SchemeHostPort(unrestricted_port_request.url), alternative_service,
-      expiration);
+      expiration, HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&unrestricted_port_request, callback.callback(),
                        NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Valid change to restricted port should pass.
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
@@ skipping 28 matching lines @@
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1025;
   AlternativeService alternative_service(kProtoHTTP2, "www.example.org",
                                          kUnrestrictedAlternatePort);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
       url::SchemeHostPort(unrestricted_port_request.url), alternative_service,
-      expiration);
+      expiration, HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&unrestricted_port_request, callback.callback(),
                        NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Valid change to an unrestricted port should pass.
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
@@ skipping 19 matching lines @@
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnsafePort = 7;
   AlternativeService alternative_service(kProtoHTTP2, "www.example.org",
                                          kUnsafePort);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(
-      url::SchemeHostPort(request.url), alternative_service, expiration);
+      url::SchemeHostPort(request.url), alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // The HTTP request should succeed.
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans.GetResponseInfo();
@@ skipping 336 matching lines @@
 
   // Configure alternative service with a hostname that is not bypassed by the
   // proxy.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   url::SchemeHostPort server("https", "www.example.org", 443);
   HostPortPair alternative("www.example.com", 443);
   AlternativeService alternative_service(kProtoHTTP2, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties->SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties->SetAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   // Non-alternative job should hang.
   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_alternate_protocol_socket(nullptr, 0,
                                                              nullptr, 0);
   hanging_alternate_protocol_socket.set_connect_data(never_finishing_connect);
   session_deps_.socket_factory->AddSocketDataProvider(
       &hanging_alternate_protocol_socket);
 
   AddSSLSocketData();
@@ skipping 2881 matching lines @@
   StaticSocketDataProvider data_refused;
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
   // Set up alternative service for server.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties->SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties->SetAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   HttpRequestInfo request;
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   request.method = "GET";
   request.url = GURL("https://www.example.org:443");
   TestCompletionCallback callback;
 
   // HTTP/2 (or SPDY) is required for alternative service, if HTTP/1.1 is
   // negotiated, the alternate Job should fail with ERR_ALPN_NEGOTIATION_FAILED.
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
@@ skipping 45 matching lines @@
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      http_writes, arraysize(http_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
 
   // Set up alternative service for server.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties->SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties->SetAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.example.org:443");
   request1.load_flags = 0;
   TestCompletionCallback callback1;
 
   int rv = trans1.Start(&request1, callback1.callback(), NetLogWithSource());
   rv = callback1.GetResult(rv);
@@ skipping 85 matching lines @@
   StaticSocketDataProvider data_refused;
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
   // Set up alternative service for server.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   AlternativeService alternative_service(kProtoHTTP2, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties->SetAlternativeService(server, alternative_service,
-                                                expiration);
+  http_server_properties->SetAlternativeService(
+      server, alternative_service, expiration,
+      HttpNetworkSession::Params().quic_supported_versions);
 
   // First transaction to alternative to open an HTTP/1.1 socket.
   HttpRequestInfo request1;
   HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
   request1.method = "GET";
   request1.url = GURL(alternative_url);
   request1.load_flags = 0;
   TestCompletionCallback callback1;
 
   int rv = trans1.Start(&request1, callback1.callback(), NetLogWithSource());
@@ skipping 2587 matching lines @@
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "", false);
 }
 
 TEST_F(HttpNetworkTransactionTest, MatchContentEncoding4) {
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "www.foo.com/other", true);
 }
 
 }  // namespace net