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

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"
@@ skipping 33 matching lines @@
   AlternativeServiceInfoVector alternative_service_info_vector;
   for (const SpdyAltSvcWireFormat::AlternativeService&
            alternative_service_entry : alternative_service_vector) {
     NextProto protocol =
         NextProtoFromString(alternative_service_entry.protocol_id);
     if (!IsAlternateProtocolValid(protocol) ||
         !session->IsProtocolEnabled(protocol) ||
         !IsPortValid(alternative_service_entry.port)) {
       continue;
     }
-    // Check if QUIC version is supported.
+    // Check if QUIC version is supported. Filter supported QUIC versions.
+    QuicVersionVector advertised_versions;
     if (protocol == kProtoQUIC && !alternative_service_entry.version.empty()) {
       bool match_found = false;
       for (QuicVersion supported : session->params().quic_supported_versions) {
         for (uint16_t advertised : alternative_service_entry.version) {
           if (supported == advertised) {
             match_found = true;
-            break;
+            advertised_versions.push_back(supported);
           }
         }
-        if (match_found) {
-          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,
-                                                    expiration);
+    AlternativeServiceInfo alternative_service_info;
+    if (protocol == kProtoQUIC) {
+      alternative_service_info =
+          AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+              alternative_service, expiration, advertised_versions);
+    } else {
+      alternative_service_info =
+          AlternativeServiceInfo::CreateHttp2AlternativeServiceInfo(
+              alternative_service, expiration);
+    }
     alternative_service_info_vector.push_back(alternative_service_info);
   }
 
   session->http_server_properties()->SetAlternativeServices(
       RewriteHost(http_server), alternative_service_info_vector);
 }
 
 HttpStreamFactory::HttpStreamFactory() {}
 
 url::SchemeHostPort HttpStreamFactory::RewriteHost(
     const url::SchemeHostPort& server) {
   HostPortPair host_port_pair(server.host(), server.port());
   const HostMappingRules* mapping_rules = GetHostMappingRules();
   if (mapping_rules)
     mapping_rules->RewriteHost(&host_port_pair);
   return url::SchemeHostPort(server.scheme(), host_port_pair.host(),
                              host_port_pair.port());
 }
 
 }  // namespace net