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

net/http/http_server_properties_manager.cc

 // Copyright 2014 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_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 44 matching lines @@
 const char kSupportsQuicKey[] = "supports_quic";
 const char kQuicServers[] = "quic_servers";
 const char kServerInfoKey[] = "server_info";
 const char kUsedQuicKey[] = "used_quic";
 const char kAddressKey[] = "address";
 const char kAlternativeServiceKey[] = "alternative_service";
 const char kProtocolKey[] = "protocol_str";
 const char kHostKey[] = "host";
 const char kPortKey[] = "port";
 const char kExpirationKey[] = "expiration";
+const char kAdvertisedVersionsKey[] = "advertised_versions";
 const char kNetworkStatsKey[] = "network_stats";
 const char kSrttKey[] = "srtt";
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
 HttpServerPropertiesManager::PrefDelegate::~PrefDelegate() {}
 
@@ skipping 117 matching lines @@
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
 AlternativeServiceInfoVector
 HttpServerPropertiesManager::GetAlternativeServiceInfos(
     const url::SchemeHostPort& origin) {
   DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetAlternativeServiceInfos(origin);
 }
 
-bool HttpServerPropertiesManager::SetAlternativeService(
+bool HttpServerPropertiesManager::SetHttp2AlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration) {
   DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
-  const bool changed = http_server_properties_impl_->SetAlternativeService(
+  const bool changed = http_server_properties_impl_->SetHttp2AlternativeService(
       origin, alternative_service, expiration);
   if (changed) {
     ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
 
+bool HttpServerPropertiesManager::SetQuicAlternativeService(
+    const url::SchemeHostPort& origin,
+    const AlternativeService& alternative_service,
+    base::Time expiration,
+    const QuicVersionVector& advertised_versions) {
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
+  const bool changed = http_server_properties_impl_->SetQuicAlternativeService(
+      origin, alternative_service, expiration, advertised_versions);
+  if (changed) {
+    ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
+  }
+  return changed;
+}
+
 bool HttpServerPropertiesManager::SetAlternativeServices(
     const url::SchemeHostPort& origin,
     const AlternativeServiceInfoVector& alternative_service_info_vector) {
   DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   const bool changed = http_server_properties_impl_->SetAlternativeServices(
       origin, alternative_service_info_vector);
   if (changed) {
     ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
@@ skipping 386 matching lines @@
 
   // Expiration is optional, defaults to one day.
   base::Time expiration;
   if (!alternative_service_dict.HasKey(kExpirationKey)) {
     alternative_service_info->set_expiration(base::Time::Now() +
                                              base::TimeDelta::FromDays(1));
     return true;
   }
 
   std::string expiration_string;
-  if (alternative_service_dict.GetStringWithoutPathExpansion(
+  if (!alternative_service_dict.GetStringWithoutPathExpansion(
           kExpirationKey, &expiration_string)) {
-    int64_t expiration_int64 = 0;
-    if (!base::StringToInt64(expiration_string, &expiration_int64)) {
-      DVLOG(1) << "Malformed alternative service expiration for server: "
+    DVLOG(1) << "Malformed alternative service expiration for server: "
+             << server_str;
+    return false;
+  }
+
+  int64_t expiration_int64 = 0;
+  if (!base::StringToInt64(expiration_string, &expiration_int64)) {
+    DVLOG(1) << "Malformed alternative service expiration for server: "
+             << server_str;
+    return false;
+  }
+  alternative_service_info->set_expiration(
+      base::Time::FromInternalValue(expiration_int64));
+
+  // Advertised versions list is optional.
+  if (!alternative_service_dict.HasKey(kAdvertisedVersionsKey))
+    return true;
+
+  const base::ListValue* versions_list = nullptr;
+  if (!alternative_service_dict.GetListWithoutPathExpansion(
+          kAdvertisedVersionsKey, &versions_list)) {
+    DVLOG(1)
+        << "Malformed alternative service advertised versions list for server: "
+        << server_str;
+    return false;
+  }
+
+  QuicVersionVector advertised_versions;
+  for (const auto& value : *versions_list) {
+    int version;
+    if (!value.GetAsInteger(&version)) {
+      DVLOG(1) << "Malformed alternative service version for server: "
                << server_str;
       return false;
     }
-    alternative_service_info->set_expiration(
-        base::Time::FromInternalValue(expiration_int64));
-    return true;
+    advertised_versions.push_back(QuicVersion(version));
   }
+  alternative_service_info->set_advertised_versions(advertised_versions);
 
-  DVLOG(1) << "Malformed alternative service expiration for server: "
-           << server_str;
-  return false;
+  return true;
 }
 
 bool HttpServerPropertiesManager::AddToAlternativeServiceMap(
     const url::SchemeHostPort& server,
     const base::DictionaryValue& server_pref_dict,
     AlternativeServiceMap* alternative_service_map) {
   DCHECK(alternative_service_map->Peek(server) ==
          alternative_service_map->end());
   const base::ListValue* alternative_service_list;
   if (!server_pref_dict.GetListWithoutPathExpansion(
@@ skipping 433 matching lines @@
     if (!alternative_service.host.empty()) {
       alternative_service_dict->SetString(kHostKey, alternative_service.host);
     }
     alternative_service_dict->SetString(
         kProtocolKey, NextProtoToString(alternative_service.protocol));
     // JSON cannot store int64_t, so expiration is converted to a string.
     alternative_service_dict->SetString(
         kExpirationKey,
         base::Int64ToString(
             alternative_service_info.expiration().ToInternalValue()));
+    std::unique_ptr<base::ListValue> advertised_versions_list =
+        base::MakeUnique<base::ListValue>();
+    for (const auto& version : alternative_service_info.advertised_versions()) {
+      advertised_versions_list->AppendInteger(version);
+    }
+    alternative_service_dict->SetList(kAdvertisedVersionsKey,
+                                      std::move(advertised_versions_list));
     alternative_service_list->Append(std::move(alternative_service_dict));
   }
   if (alternative_service_list->GetSize() == 0)
     return;
   server_pref_dict->SetWithoutPathExpansion(
       kAlternativeServiceKey, std::move(alternative_service_list));
 }
 
 void HttpServerPropertiesManager::SaveSupportsQuicToPrefs(
     const IPAddress* last_quic_address,
@@ skipping 49 matching lines @@
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 void HttpServerPropertiesManager::SetInitialized() {
   DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   is_initialized_ = true;
 }
 
 }  // namespace net