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

net/http/http_stream_factory_impl_job_controller_unittest.cc

 // Copyright (c) 2016 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_job_controller.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 140 matching lines @@
     return job->GetSpdySessionKey();
   }
 };
 
 class JobControllerPeer {
  public:
   static bool main_job_is_blocked(
       HttpStreamFactoryImpl::JobController* job_controller) {
     return job_controller->main_job_is_blocked_;
   }
+
   static bool main_job_is_resumed(
       HttpStreamFactoryImpl::JobController* job_controller) {
     return job_controller->main_job_is_resumed_;
   }
+
+  static AlternativeServiceInfo GetAlternativeServiceInfoFor(
+      HttpStreamFactoryImpl::JobController* job_controller,
+      const HttpRequestInfo& request_info,
+      HttpStreamRequest::Delegate* delegate,
+      HttpStreamRequest::StreamType stream_type) {
+    return job_controller->GetAlternativeServiceInfoFor(request_info, delegate,
+                                                        stream_type);
+  }
 };
 
 class HttpStreamFactoryImplJobControllerTest : public ::testing::Test {
  public:
   HttpStreamFactoryImplJobControllerTest()
       : session_deps_(ProxyService::CreateDirect()),
         random_generator_(0),
         client_maker_(HttpNetworkSession::Params().quic_supported_versions[0],
                       0,
                       &clock_,
@@ skipping 79 matching lines @@
       EXPECT_TRUE(tcp_data_->AllWriteDataConsumed());
     }
   }
 
   void SetAlternativeService(const HttpRequestInfo& request_info,
                              AlternativeService alternative_service) {
     HostPortPair host_port_pair = HostPortPair::FromURL(request_info.url);
     url::SchemeHostPort server(request_info.url);
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     session_->http_server_properties()->SetAlternativeService(
-        server, alternative_service, expiration);
+        server, alternative_service, expiration,
+        HttpNetworkSession::Params().quic_supported_versions);
   }
 
   void VerifyBrokenAlternateProtocolMapping(const HttpRequestInfo& request_info,
                                             bool should_mark_broken) {
     const url::SchemeHostPort server(request_info.url);
     const AlternativeServiceInfoVector alternative_service_info_vector =
         session_->http_server_properties()->GetAlternativeServiceInfos(server);
     EXPECT_EQ(1u, alternative_service_info_vector.size());
     EXPECT_EQ(should_mark_broken,
               session_->http_server_properties()->IsAlternativeServiceBroken(
@@ skipping 56 matching lines @@
 
   base::RunLoop().RunUntilIdle();
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, ProxyResolutionFailsAsync) {
   ProxyConfig proxy_config;
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
   proxy_config.set_pac_mandatory(true);
-  MockAsyncProxyResolverFactory* proxy_resolver_factory =
-      new MockAsyncProxyResolverFactory(false);
-  MockAsyncProxyResolver resolver;
-  session_deps_.proxy_service.reset(
-      new ProxyService(base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
-                       base::WrapUnique(proxy_resolver_factory), nullptr));
+  session_deps_.proxy_service.reset(new ProxyService(

[Bence, 2017/06/08 17:44:51]

session_deps_.proxy_service = base::MakeUnique<ProxyService>(

[Zhongyi Shi, 2017/06/08 23:11:16]

This is a change not related to this CL. Not sure what's up here, but apparently
I had some conflicts when rebase. I will resolve this after a new rebase. 

+      base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
+      base::WrapUnique(new FailingProxyResolverFactory), nullptr));

[Bence, 2017/06/08 17:44:52]

base::MakeUnique<FailingProxyResolverFactory>()

[Zhongyi Shi, 2017/06/08 23:11:16]

ditto.

   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   Initialize(request_info);
 
+  EXPECT_CALL(request_delegate_,
+              OnStreamFailed(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, _))
+      .Times(1);
   request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
                              HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   EXPECT_FALSE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->alternative_job());
 
-  EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL,
-            job_controller_->GetLoadState());
+  // Make sure calling GetLoadState() when before job
+  // creation does not crash.
+  // Regression test for crbug.com/723920.
+  EXPECT_EQ(LOAD_STATE_IDLE, job_controller_->GetLoadState());
 
-  EXPECT_CALL(request_delegate_,
-              OnStreamFailed(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, _))
-      .Times(1);
-  proxy_resolver_factory->pending_requests()[0]->CompleteNowWithForwarder(
-      ERR_FAILED, &resolver);
   base::RunLoop().RunUntilIdle();
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, NoSupportedProxies) {
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("QUIC myproxy.org:443");
   session_deps_.enable_quic = false;
   HttpRequestInfo request_info;
@@ skipping 1343 matching lines @@
   Initialize();
   Preconnect(kNumPreconects);
   // If experiment is enabled, only 1 stream is requested.
   EXPECT_EQ(
       (int)actual_num_connects,
       HttpStreamFactoryImplJobPeer::GetNumStreams(job_controller_->main_job()));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
+// Test that GetAlternativeServiceInfoFor will include a list of advertised
+// versions.
+TEST_F(HttpStreamFactoryImplJobControllerTest, GetAlternativeServiceInfoFor) {
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.google.com");
+
+  Initialize(request_info);
+  url::SchemeHostPort server(request_info.url);
+  AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
+  HostPortPair host_port_pair = HostPortPair::FromURL(request_info.url);
+  base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
+
+  // Set alternative service with no advertised version, JobController will
+  // append default supported quic versions when get alternative service info.
+  session_->http_server_properties()->SetAlternativeService(
+      server, alternative_service, expiration, QuicVersionVector());
+
+  AlternativeServiceInfo alt_svc_info =
+      JobControllerPeer::GetAlternativeServiceInfoFor(
+          job_controller_, request_info, &request_delegate_,
+          HttpStreamRequest::HTTP_STREAM);
+  const QuicVersionVector supported_versions =
+      session_->params().quic_supported_versions;
+  // Verify that JobController appends list of supported QUIC versions.
+  EXPECT_EQ(supported_versions.size(),
+            alt_svc_info.advertised_versions().size());
+  for (unsigned int i = 0; i < supported_versions.size(); i++) {
+    EXPECT_EQ(supported_versions[i], alt_svc_info.advertised_versions()[i]);
+  }
+
+  // Set alternative service for the same server with QUIC_VERSION_39 specified.
+  ASSERT_TRUE(session_->http_server_properties()->SetAlternativeService(
+      server, alternative_service, expiration, {QUIC_VERSION_39}));
+
+  alt_svc_info = JobControllerPeer::GetAlternativeServiceInfoFor(
+      job_controller_, request_info, &request_delegate_,
+      HttpStreamRequest::HTTP_STREAM);
+  EXPECT_EQ(1u, alt_svc_info.advertised_versions().size());
+  // Verify that JobController returns the single version specified in set.
+  EXPECT_EQ(QUIC_VERSION_39, alt_svc_info.advertised_versions()[0]);
+
+  // Set alternative service for the same server with two QUIC versions:
+  // QUIC_VERSION_35, QUIC_VERSION_39.
+  ASSERT_TRUE(session_->http_server_properties()->SetAlternativeService(
+      server, alternative_service, expiration,
+      {QUIC_VERSION_35, QUIC_VERSION_39}));
+
+  alt_svc_info = JobControllerPeer::GetAlternativeServiceInfoFor(
+      job_controller_, request_info, &request_delegate_,
+      HttpStreamRequest::HTTP_STREAM);
+  EXPECT_EQ(2u, alt_svc_info.advertised_versions().size());
+  // Verify that JobController returns the list of versions specified in set.
+  EXPECT_EQ(QUIC_VERSION_35, alt_svc_info.advertised_versions()[0]);
+  EXPECT_EQ(QUIC_VERSION_39, alt_svc_info.advertised_versions()[1]);
+}
+
 }  // namespace net