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

net/http/http_server_properties_impl.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_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 269 matching lines @@
       if (alternative_service.host.empty()) {
         alternative_service.host = origin.host();
       }
       // If the alternative service is equivalent to the origin (same host, same
       // port, and both TCP), skip it.
       if (host_port_pair.Equals(alternative_service.host_port_pair()) &&
           alternative_service.protocol == kProtoHTTP2) {
         ++it;
         continue;
       }
-      valid_alternative_service_infos.push_back(
-          AlternativeServiceInfo(alternative_service, it->expiration()));
+      if (alternative_service.protocol == kProtoQUIC) {
+        valid_alternative_service_infos.push_back(
+            AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+                alternative_service, it->expiration(),
+                it->advertised_versions()));
+      } else {
+        valid_alternative_service_infos.push_back(
+            AlternativeServiceInfo::CreateHttp2AlternativeServiceInfo(
+                alternative_service, it->expiration()));
+      }
       ++it;
     }
     if (map_it->second.empty()) {
       alternative_service_map_.Erase(map_it);
     }
     return valid_alternative_service_infos;
   }
 
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(origin);
   if (canonical == canonical_host_to_origin_map_.end()) {
@@ skipping 14 matching lines @@
       alternative_service.host = canonical->second.host();
       if (IsAlternativeServiceBroken(alternative_service)) {
         ++it;
         continue;
       }
       alternative_service.host = origin.host();
     } else if (IsAlternativeServiceBroken(alternative_service)) {
       ++it;
       continue;
     }
-    valid_alternative_service_infos.push_back(
-        AlternativeServiceInfo(alternative_service, it->expiration()));
+    if (alternative_service.protocol == kProtoQUIC) {
+      valid_alternative_service_infos.push_back(
+          AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+              alternative_service, it->expiration(),
+              it->advertised_versions()));
+    } else {
+      valid_alternative_service_infos.push_back(
+          AlternativeServiceInfo::CreateHttp2AlternativeServiceInfo(
+              alternative_service, it->expiration()));
+    }
     ++it;
   }
   if (map_it->second.empty()) {
     alternative_service_map_.Erase(map_it);
   }
   return valid_alternative_service_infos;
 }
 
-bool HttpServerPropertiesImpl::SetAlternativeService(
+bool HttpServerPropertiesImpl::SetHttp2AlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration) {
+  DCHECK_EQ(alternative_service.protocol, kProtoHTTP2);
+
   return SetAlternativeServices(
       origin,
       AlternativeServiceInfoVector(
-          /*size=*/1, AlternativeServiceInfo(alternative_service, expiration)));
+          /*size=*/1, AlternativeServiceInfo::CreateHttp2AlternativeServiceInfo(
+                          alternative_service, expiration)));
+}
+
+bool HttpServerPropertiesImpl::SetQuicAlternativeService(
+    const url::SchemeHostPort& origin,
+    const AlternativeService& alternative_service,
+    base::Time expiration,
+    const QuicVersionVector& advertised_versions) {
+  DCHECK(alternative_service.protocol == kProtoQUIC);
+
+  return SetAlternativeServices(
+      origin, AlternativeServiceInfoVector(
+                  /*size=*/1,
+                  AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+                      alternative_service, expiration, advertised_versions)));
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeServices(
     const url::SchemeHostPort& origin,
     const AlternativeServiceInfoVector& alternative_service_info_vector) {
   AlternativeServiceMap::iterator it = alternative_service_map_.Peek(origin);
 
   if (alternative_service_info_vector.empty()) {
     RemoveCanonicalHost(origin);
     if (it == alternative_service_map_.end())
@@ skipping 19 matching lines @@
         }
         // Also persist to disk if new expiration it more that twice as far or
         // less than half as far in the future.
         base::Time old_time = old.expiration();
         base::Time new_time = new_it->expiration();
         if (new_time - now > 2 * (old_time - now) ||
             2 * (new_time - now) < (old_time - now)) {
           changed = true;
           break;
         }
+        // Also persist to disk if new entry has a different list of advertised
+        // versions.
+        if (old.advertised_versions() != new_it->advertised_versions()) {
+          changed = true;
+          break;
+        }
         ++new_it;
       }
     }
   }
 
   const bool previously_no_alternative_services =
       (GetAlternateProtocolIterator(origin) == alternative_service_map_.end());
 
   alternative_service_map_.Put(origin, alternative_service_info_vector);
 
@@ skipping 267 matching lines @@
     if (map_it->second.empty()) {
       RemoveCanonicalHost(map_it->first);
       map_it = alternative_service_map_.Erase(map_it);
       continue;
     }
     ++map_it;
   }
 }
 
 }  // namespace net