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;
 }
 
+// static
+AlternativeServiceInfo
+AlternativeServiceInfo::CreateHttp2AlternativeServiceInfo(
+    const AlternativeService& alternative_service,
+    base::Time expiration) {
+  DCHECK_EQ(alternative_service.protocol, kProtoHTTP2);
+  return AlternativeServiceInfo(alternative_service, expiration,
+                                QuicVersionVector());
+}
+
+// static
+AlternativeServiceInfo AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+    const AlternativeService& alternative_service,
+    base::Time expiration,
+    const QuicVersionVector& advertised_versions) {
+  DCHECK_EQ(alternative_service.protocol, kProtoQUIC);
+  return AlternativeServiceInfo(alternative_service, expiration,
+                                advertised_versions);
+}
+
 AlternativeServiceInfo::AlternativeServiceInfo() : alternative_service_() {}
 
+AlternativeServiceInfo::~AlternativeServiceInfo() {}
+
 AlternativeServiceInfo::AlternativeServiceInfo(
     const AlternativeService& alternative_service,
-    base::Time expiration)
-    : alternative_service_(alternative_service), expiration_(expiration) {}
-
-AlternativeServiceInfo::AlternativeServiceInfo(NextProto protocol,
-                                               const std::string& host,
-                                               uint16_t port,
-                                               base::Time expiration)
-    : alternative_service_(protocol, host, port), expiration_(expiration) {}
+    base::Time expiration,
+    const QuicVersionVector& advertised_versions)
+    : alternative_service_(alternative_service), expiration_(expiration) {
+  if (alternative_service_.protocol == kProtoQUIC) {
+    advertised_versions_ = advertised_versions;
+    std::sort(advertised_versions_.begin(), advertised_versions_.end());
+  }
+}
 
 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);
@@ skipping 14 matching lines @@
   return os;
 }
 
 // static
 void HttpServerProperties::ForceHTTP11(SSLConfig* ssl_config) {
   ssl_config->alpn_protos.clear();
   ssl_config->alpn_protos.push_back(kProtoHTTP11);
 }
 
 }  // namespace net