Observe v= parameter when processing Alternative Services header.

net/http/http_stream_factory.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.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/port_util.h"
 #include "net/http/http_network_session.h"
+#include "net/quic/quic_protocol.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "url/gurl.h"
 
 namespace net {
 
 // WARNING: If you modify or add any static flags, you must keep them in sync
 // with |ResetStaticSettingsToInit|. This is critical for unit test isolation.
 
 // static
 bool HttpStreamFactory::spdy_enabled_ = true;
@@ skipping 21 matching lines @@
   AlternativeServiceInfoVector alternative_service_info_vector;
   for (const SpdyAltSvcWireFormat::AlternativeService&
            alternative_service_entry : alternative_service_vector) {
     AlternateProtocol protocol =
         AlternateProtocolFromString(alternative_service_entry.protocol_id);
     if (!IsAlternateProtocolValid(protocol) ||
         !session.IsProtocolEnabled(protocol) ||
         !IsPortValid(alternative_service_entry.port)) {
       continue;
     }
+    // Check if QUIC version is supported.
+    if (protocol == QUIC && !alternative_service_entry.version.empty()) {
+      SpdyAltSvcWireFormat::VersionVector::const_iterator begin =
+          alternative_service_entry.version.begin();
+      SpdyAltSvcWireFormat::VersionVector::const_iterator end =
+          alternative_service_entry.version.end();
+      bool match_found = false;
+      for (QuicVersion supported : session.params().quic_supported_versions) {
+        if (std::find(begin, end, static_cast<uint16>(supported)) != end) {
+          match_found = true;

[Ryan Hamilton, 2015/10/29 20:07:23]

Up to you, but instead of using std::find, I wonder if would be easier to do:
  for (uint16 alt_version : alternative_service_entry) {
    if (supported == alt_version) {
      match_found = true;
      break;
    }
  }

I hate iterators, but I have lots of pet peeves :> You don't need to share my
peeves :>

+          break;
+        }
+      }
+      if (!match_found) {
+        continue;
+      }
+    }
     AlternativeService alternative_service(protocol,
                                            alternative_service_entry.host,
                                            alternative_service_entry.port);
     base::Time expiration =
         base::Time::Now() +
         base::TimeDelta::FromSeconds(alternative_service_entry.max_age);
     AlternativeServiceInfo alternative_service_info(
         alternative_service, alternative_service_entry.probability, expiration);
     alternative_service_info_vector.push_back(alternative_service_info);
   }
@@ skipping 87 matching lines @@
 HttpStreamFactory::HttpStreamFactory() {}
 
 HostPortPair HttpStreamFactory::RewriteHost(HostPortPair host_port_pair) {
   const HostMappingRules* mapping_rules = GetHostMappingRules();
   if (mapping_rules)
     mapping_rules->RewriteHost(&host_port_pair);
   return host_port_pair;
 }
 
 }  // namespace net