JobController: do not create alternative job for those AlternativeServiceInfo

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 1115 matching lines @@
       continue;
 
     if (stream_type == HttpStreamRequest::BIDIRECTIONAL_STREAM &&
         session_->params().quic_disable_bidirectional_streams) {
       continue;
     }
 
     if (!original_url.SchemeIs(url::kHttpsScheme))
       continue;
 
+    // If there is no QUIC version in the advertised versions supported by
+    // the net stack, ignore this entry.
+    if (SelectQuicVersion(alternative_service_info.advertised_versions()) ==
+        QUIC_VERSION_UNSUPPORTED)

[Ryan Hamilton, 2017/06/30 02:45:11]

Since we don't do anything with the return value from this method, should it
just return bool?

[Zhongyi Shi, 2017/06/30 21:08:43]

I could change to return a boolean in this one, the reason I return a
QuicVersion here is that this method can be reused when JobController selects
the best QuicVersion and plumbs to alt Job constructor. 

[Ryan Hamilton, 2017/06/30 21:17:31]

Makes sense.

+      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());
     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)
       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;
 }
 
+QuicVersion HttpStreamFactoryImpl::JobController::SelectQuicVersion(
+    const QuicVersionVector& advertised_versions) {
+  const QuicVersionVector& supported_versions =
+      session_->params().quic_supported_versions;
+  if (advertised_versions.empty())
+    return supported_versions[0];
+
+  for (const QuicVersion& supported : supported_versions) {
+    for (const QuicVersion& advertised : advertised_versions) {
+      if (supported == advertised) {
+        DCHECK_NE(QUIC_VERSION_UNSUPPORTED, supported);
+        return supported;
+      }
+    }
+  }
+
+  return QUIC_VERSION_UNSUPPORTED;
+}
+
 bool HttpStreamFactoryImpl::JobController::
     ShouldCreateAlternativeProxyServerJob(
         const ProxyInfo& proxy_info,
         const GURL& url,
         ProxyServer* alternative_proxy_server) const {
   DCHECK(!alternative_proxy_server->is_valid());
 
   if (!enable_alternative_services_)
     return false;
 
@@ skipping 113 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