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

net/http/http_server_properties.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_server_properties.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
+#include "net/http/http_network_session.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/ssl_config.h"
 
 namespace net {
 
 namespace {
 
 enum AlternativeProxyUsage {
   // Alternative Proxy was used without racing a normal connection.
   ALTERNATIVE_PROXY_USAGE_NO_RACE = 0,
@@ skipping 51 matching lines @@
       return false;
     case kProtoHTTP2:
       return true;
     case kProtoQUIC:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
+AlternativeServiceInfo::AlternativeServiceInfo() : alternative_service() {}
+
+AlternativeServiceInfo::~AlternativeServiceInfo() {}
+
+AlternativeServiceInfo::AlternativeServiceInfo(
+    const AlternativeService& alternative_service,
+    base::Time expiration)
+    : alternative_service(alternative_service), expiration(expiration) {
+  if (alternative_service.protocol == kProtoQUIC)
+    advertised_versions = HttpNetworkSession::Params().quic_supported_versions;

[Ryan Hamilton, 2017/05/25 22:01:45]

I don't think this is the right thing to do. This is the default list of
version. It is not the set of versions used by the current instance of the
network stack, may have been configured via finch or command line flag.

+}
+
+AlternativeServiceInfo::AlternativeServiceInfo(
+    const AlternativeServiceInfo& alternative_service_info) = default;
+
+AlternativeServiceInfo& AlternativeServiceInfo::operator=(
+    const AlternativeServiceInfo& alternative_service_info) = default;
+
 std::string AlternativeService::ToString() const {
   return base::StringPrintf("%s %s:%d", NextProtoToString(protocol),
                             host.c_str(), port);
 }
 
 std::string AlternativeServiceInfo::ToString() const {
   base::Time::Exploded exploded;
   expiration.LocalExplode(&exploded);
   return base::StringPrintf(
       "%s, expires %04d-%02d-%02d %02d:%02d:%02d",
       alternative_service.ToString().c_str(), exploded.year, exploded.month,
       exploded.day_of_month, exploded.hour, exploded.minute, exploded.second);
 }
 
 std::ostream& operator<<(std::ostream& os,
                          const AlternativeService& alternative_service) {
   os << alternative_service.ToString();
   return os;
 }
 
 // static
 void HttpServerProperties::ForceHTTP11(SSLConfig* ssl_config) {
   ssl_config->alpn_protos.clear();
   ssl_config->alpn_protos.push_back(kProtoHTTP11);
 }
 
 }  // namespace net