Change QuicStreamRequest::Request() to take a preferred QuicVersion so that

net/http/http_stream_factory_impl_job_controller.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 "base/memory/ptr_util.h"
@@ skipping 615 matching lines @@
   CHECK(request_);
   session_->spdy_session_pool()->RemoveRequestFromSpdySessionRequestMap(
       request_);
 }
 
 const NetLogWithSource* HttpStreamFactoryImpl::JobController::GetNetLog()
     const {
   return &net_log_;
 }
 
+const QuicVersionVector&
+HttpStreamFactoryImpl::JobController::GetAdvertisedQuicVersions() const {
+  return alternative_service_info_.advertised_versions();
+}
+
 void HttpStreamFactoryImpl::JobController::MaybeSetWaitTimeForMainJob(
     const base::TimeDelta& delay) {
   if (main_job_is_blocked_) {
     main_job_wait_time_ = std::min(
         delay, base::TimeDelta::FromSeconds(kMaxDelayTimeForMainJobSecs));
   }
 }
 
 bool HttpStreamFactoryImpl::JobController::HasPendingMainJob() const {
   return main_job_.get() != nullptr;
@@ skipping 117 matching lines @@
 }
 
 int HttpStreamFactoryImpl::JobController::DoCreateJobs() {
   DCHECK(!main_job_);
   DCHECK(!alternative_job_);
 
   HostPortPair destination(HostPortPair::FromURL(request_info_.url));
   GURL origin_url = ApplyHostMappingRules(request_info_.url, &destination);
 
   // Create an alternative job if alternative service is set up for this domain.
-  alternative_service_ =
-      GetAlternativeServiceInfoFor(request_info_, delegate_, stream_type_)
-          .alternative_service();
+  alternative_service_info_ =
+      GetAlternativeServiceInfoFor(request_info_, delegate_, stream_type_);
 
   if (is_preconnect_) {
     // Due to how the socket pools handle priorities and idle sockets, only IDLE
     // priority currently makes sense for preconnects. The priority for
     // preconnects is currently ignored (see RequestSocketsForPool()), but could
     // be used at some point for proxy resolution or something.
-    if (alternative_service_.protocol != kProtoUnknown) {
+    if (alternative_service_info_.protocol() != kProtoUnknown) {
       HostPortPair alternative_destination(
-          alternative_service_.host_port_pair());
+          alternative_service_info_.host_port_pair());
       ignore_result(
           ApplyHostMappingRules(request_info_.url, &alternative_destination));
       main_job_ = job_factory_->CreateAltSvcJob(
           this, PRECONNECT, session_, request_info_, IDLE, proxy_info_,
           server_ssl_config_, proxy_ssl_config_, alternative_destination,
-          origin_url, alternative_service_.protocol, enable_ip_based_pooling_,
-          session_->net_log());
+          origin_url, alternative_service_info_.protocol(),
+          enable_ip_based_pooling_, session_->net_log());
     } else {
       main_job_ = job_factory_->CreateMainJob(
           this, PRECONNECT, session_, request_info_, IDLE, proxy_info_,
           server_ssl_config_, proxy_ssl_config_, destination, origin_url,
           enable_ip_based_pooling_, session_->net_log());
     }
     main_job_->Preconnect(num_streams_);
     return OK;
   }
   main_job_ = job_factory_->CreateMainJob(
       this, MAIN, session_, request_info_, priority_, proxy_info_,
       server_ssl_config_, proxy_ssl_config_, destination, origin_url,
       enable_ip_based_pooling_, net_log_.net_log());
   // Alternative Service can only be set for HTTPS requests while Alternative
   // Proxy is set for HTTP requests.
-  if (alternative_service_.protocol != kProtoUnknown) {
+  if (alternative_service_info_.protocol() != kProtoUnknown) {
     // Never share connection with other jobs for FTP requests.
     DVLOG(1) << "Selected alternative service (host: "
-             << alternative_service_.host_port_pair().host()
-             << " port: " << alternative_service_.host_port_pair().port()
+             << alternative_service_info_.host_port_pair().host()
+             << " port: " << alternative_service_info_.host_port_pair().port()
              << ")";
 
     DCHECK(!request_info_.url.SchemeIs(url::kFtpScheme));
-    HostPortPair alternative_destination(alternative_service_.host_port_pair());
+    HostPortPair alternative_destination(
+        alternative_service_info_.host_port_pair());
     ignore_result(
         ApplyHostMappingRules(request_info_.url, &alternative_destination));
 
     alternative_job_ = job_factory_->CreateAltSvcJob(
         this, ALTERNATIVE, session_, request_info_, priority_, proxy_info_,
         server_ssl_config_, proxy_ssl_config_, alternative_destination,
-        origin_url, alternative_service_.protocol, enable_ip_based_pooling_,
-        net_log_.net_log());
+        origin_url, alternative_service_info_.protocol(),

[Ryan Hamilton, 2017/06/28 18:53:14]

Since we're already passing in some of the AlternateServiceInfo fields into the
AltJob constructor, how 'bout passing in either all of it, or just the QUIC
versions and avoiding the upcall to fetch advertised QUIC versions from the Job?

[Zhongyi Shi, 2017/07/05 23:08:59]

Done. Changed to only pass the selected QUIC version.

+        enable_ip_based_pooling_, net_log_.net_log());
 
     main_job_is_blocked_ = true;
     alternative_job_->Start(request_->stream_type());
   } else {
     ProxyServer alternative_proxy_server;
     if (ShouldCreateAlternativeProxyServerJob(proxy_info_, request_info_.url,
                                               &alternative_proxy_server)) {
       DCHECK(!main_job_is_blocked_);
       ProxyInfo alternative_proxy_info;
       alternative_proxy_info.UseProxyServer(alternative_proxy_server);
@@ skipping 107 matching lines @@
     NextProto negotiated_protocol,
     bool using_spdy) {
   if (request_)
     request_->Complete(was_alpn_negotiated, negotiated_protocol, using_spdy);
 }
 
 void HttpStreamFactoryImpl::JobController::OnAlternativeServiceJobFailed(
     int net_error) {
   DCHECK_EQ(alternative_job_->job_type(), ALTERNATIVE);
   DCHECK_NE(OK, net_error);
-  DCHECK_NE(kProtoUnknown, alternative_service_.protocol);
+  DCHECK_NE(kProtoUnknown, alternative_service_info_.protocol());
 
   alternative_job_net_error_ = net_error;
 
   if (IsJobOrphaned(alternative_job_.get())) {
     // If |request_| is gone then it must have been successfully served by
     // |main_job_|.
     // If |request_| is bound to a different job, then it is being
     // successfully serverd by the main job.
     ReportBrokenAlternativeService();
   }
 }
 
 void HttpStreamFactoryImpl::JobController::OnAlternativeProxyJobFailed(
     int net_error) {
   DCHECK_EQ(alternative_job_->job_type(), ALTERNATIVE);
   DCHECK_NE(OK, net_error);
   DCHECK(alternative_job_->alternative_proxy_server().is_valid());
 
   // Need to mark alt proxy as broken regardless whether the job is bound.
   ProxyDelegate* proxy_delegate = session_->context().proxy_delegate;
   if (proxy_delegate) {
     proxy_delegate->OnAlternativeProxyBroken(
         alternative_job_->alternative_proxy_server());
   }
 }
 
 void HttpStreamFactoryImpl::JobController::ReportBrokenAlternativeService() {
-  DCHECK(alternative_service_.protocol != kProtoUnknown);
+  DCHECK(alternative_service_info_.protocol() != kProtoUnknown);
   DCHECK_NE(OK, alternative_job_net_error_);
 
   int error_to_report = alternative_job_net_error_;
   alternative_job_net_error_ = OK;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.AlternateServiceFailed", -error_to_report);
 
   if (error_to_report == ERR_NETWORK_CHANGED ||
       error_to_report == ERR_INTERNET_DISCONNECTED) {
     // No need to mark alternative service or proxy as broken.
     return;
   }
 
   HistogramBrokenAlternateProtocolLocation(
       BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT);
   session_->http_server_properties()->MarkAlternativeServiceBroken(
-      alternative_service_);
+      alternative_service_info_.alternative_service());
 }
 
 void HttpStreamFactoryImpl::JobController::MaybeNotifyFactoryOfCompletion() {
   if (!request_ && !main_job_ && !alternative_job_) {
     DCHECK(!bound_job_);
     factory_->OnJobControllerComplete(this);
   }
 }
 
 void HttpStreamFactoryImpl::JobController::NotifyRequestFailed(int rv) {
@@ skipping 20 matching lines @@
 HttpStreamFactoryImpl::JobController::GetAlternativeServiceInfoFor(
     const HttpRequestInfo& request_info,
     HttpStreamRequest::Delegate* delegate,
     HttpStreamRequest::StreamType stream_type) {
   if (!enable_alternative_services_)
     return AlternativeServiceInfo();
 
   AlternativeServiceInfo alternative_service_info =
       GetAlternativeServiceInfoInternal(request_info, delegate, stream_type);
   AlternativeServiceType type;
-  if (alternative_service_info.alternative_service().protocol ==
-      kProtoUnknown) {
+  if (alternative_service_info.protocol() == kProtoUnknown) {
     type = NO_ALTERNATIVE_SERVICE;
-  } else if (alternative_service_info.alternative_service().protocol ==
-             kProtoQUIC) {
+  } else if (alternative_service_info.protocol() == kProtoQUIC) {
     if (request_info.url.host_piece() ==
         alternative_service_info.alternative_service().host) {
       type = QUIC_SAME_DESTINATION;
     } else {
       type = QUIC_DIFFERENT_DESTINATION;
     }
   } else {
     if (request_info.url.host_piece() ==
         alternative_service_info.alternative_service().host) {
       type = NOT_QUIC_SAME_DESTINATION;
@@ skipping 25 matching lines @@
     return AlternativeServiceInfo();
 
   bool quic_advertised = false;
   bool quic_all_broken = true;
 
   // First alternative service that is not marked as broken.
   AlternativeServiceInfo first_alternative_service_info;
 
   for (const AlternativeServiceInfo& alternative_service_info :
        alternative_service_info_vector) {
-    DCHECK(IsAlternateProtocolValid(
-        alternative_service_info.alternative_service().protocol));
-    if (!quic_advertised &&
-        alternative_service_info.alternative_service().protocol == kProtoQUIC)
+    DCHECK(IsAlternateProtocolValid(alternative_service_info.protocol()));
+    if (!quic_advertised && alternative_service_info.protocol() == kProtoQUIC)
       quic_advertised = true;
     if (http_server_properties.IsAlternativeServiceBroken(
             alternative_service_info.alternative_service())) {
       HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN, false);
       continue;
     }
 
     // Some shared unix systems may have user home directories (like
     // http://foo.com/~mike) which allow users to emit headers.  This is a bad
     // idea already, but with Alternate-Protocol, it provides the ability for a
     // single user on a multi-user system to hijack the alternate protocol.
     // These systems also enforce ports <1024 as restricted ports.  So don't
     // allow protocol upgrades to user-controllable ports.
     const int kUnrestrictedPort = 1024;
     if (!session_->params().enable_user_alternate_protocol_ports &&
         (alternative_service_info.alternative_service().port >=
              kUnrestrictedPort &&
          origin.port() < kUnrestrictedPort))
       continue;
 
-    if (alternative_service_info.alternative_service().protocol ==
-        kProtoHTTP2) {
+    if (alternative_service_info.protocol() == kProtoHTTP2) {
       if (!session_->params().enable_http2_alternative_service)
         continue;
 
       // Cache this entry if we don't have a non-broken Alt-Svc yet.
-      if (first_alternative_service_info.alternative_service().protocol ==
-          kProtoUnknown)
+      if (first_alternative_service_info.protocol() == kProtoUnknown)
         first_alternative_service_info = alternative_service_info;
       continue;
     }
 
-    DCHECK_EQ(kProtoQUIC,
-              alternative_service_info.alternative_service().protocol);
+    DCHECK_EQ(kProtoQUIC, alternative_service_info.protocol());
     quic_all_broken = false;
     if (!session_->IsQuicEnabled())
       continue;
 
     if (stream_type == HttpStreamRequest::BIDIRECTIONAL_STREAM &&
         session_->params().quic_disable_bidirectional_streams) {
       continue;
     }
 
     if (!original_url.SchemeIs(url::kHttpsScheme))
       continue;
 
     // Check whether there is an existing QUIC session to use for this origin.
     HostPortPair mapped_origin(origin.host(), origin.port());
     ignore_result(ApplyHostMappingRules(original_url, &mapped_origin));
     QuicServerId server_id(mapped_origin, request_info.privacy_mode);
 
-    HostPortPair destination(
-        alternative_service_info.alternative_service().host_port_pair());
+    HostPortPair destination(alternative_service_info.host_port_pair());
     ignore_result(ApplyHostMappingRules(original_url, &destination));
 
     if (session_->quic_stream_factory()->CanUseExistingSession(server_id,
                                                                destination)) {
       return alternative_service_info;
     }
 
     // Cache this entry if we don't have a non-broken Alt-Svc yet.
-    if (first_alternative_service_info.alternative_service().protocol ==
-        kProtoUnknown)
+    if (first_alternative_service_info.protocol() == kProtoUnknown)
       first_alternative_service_info = alternative_service_info;
   }
 
   // Ask delegate to mark QUIC as broken for the origin.
   if (quic_advertised && quic_all_broken && delegate != nullptr)
     delegate->OnQuicBroken();
 
   return first_alternative_service_info;
 }
 
@@ skipping 123 matching lines @@
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     // TODO(eroman): This is a confusing contract, make it more obvious.
     rv = error;
   }
   return rv;
 }
 
 }  // namespace net