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 308 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));
+      valid_alternative_service_infos.push_back(AlternativeServiceInfo(
+          alternative_service, it->expiration, it->advertised_versions()));
       ++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));
+    valid_alternative_service_infos.push_back(AlternativeServiceInfo(
+        alternative_service, it->expiration, it->advertised_versions()));
     ++it;
   }
   if (map_it->second.empty()) {
     alternative_service_map_.Erase(map_it);
   }
   return valid_alternative_service_infos;
 }
 
 bool HttpServerPropertiesImpl::SetAlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
-    base::Time expiration) {
+    base::Time expiration,
+    const QuicVersionVector& advertised_versions) {
   return SetAlternativeServices(
       origin,
       AlternativeServiceInfoVector(
-          /*size=*/1, AlternativeServiceInfo(alternative_service, expiration)));
+          /*size=*/1, AlternativeServiceInfo(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 advertised versions change significantly for
+        // QUIC.
+        if (!old.EqualAdvertisedVersions(*new_it)) {
+          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 335 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net