QUIC - Allow cronet apps to specify how many server configs are to be

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 "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 388 matching lines @@
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetQuicServerInfo(server_id);
 }
 
 const QuicServerInfoMap& HttpServerPropertiesManager::quic_server_info_map()
     const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->quic_server_info_map();
 }
 
+size_t HttpServerPropertiesManager::max_server_configs_stored_in_properties()
+    const {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  return http_server_properties_impl_
+      ->max_server_configs_stored_in_properties();
+}
+
+void HttpServerPropertiesManager::SetMaxServerConfigsStoredInProperties(
+    size_t max_server_configs_stored_in_properties) {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  return http_server_properties_impl_->SetMaxServerConfigsStoredInProperties(
+      max_server_configs_stored_in_properties);
+}
+
 //
 // Update the HttpServerPropertiesImpl's cache with data from preferences.
 //
 void HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   // Cancel pending updates, if any.
   pref_cache_update_timer_->Stop();
   StartCacheUpdateTimerOnPrefThread(
       base::TimeDelta::FromMilliseconds(kUpdateCacheDelayMs));
 }
@@ skipping 71 matching lines @@
 
   // String is host/port pair of spdy server.
   scoped_ptr<ServerList> spdy_servers(new ServerList);
   scoped_ptr<SpdySettingsMap> spdy_settings_map(
       new SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
   scoped_ptr<AlternativeServiceMap> alternative_service_map(
       new AlternativeServiceMap(kMaxAlternateProtocolHostsToPersist));
   scoped_ptr<ServerNetworkStatsMap> server_network_stats_map(
       new ServerNetworkStatsMap(kMaxServerNetworkStatsHostsToPersist));
   scoped_ptr<QuicServerInfoMap> quic_server_info_map(
-      new QuicServerInfoMap(kMaxQuicServersToPersist));
+      new QuicServerInfoMap(QuicServerInfoMap::NO_AUTO_EVICT));
 
   if (version < 4) {
     if (!AddServersData(*servers_dict, spdy_servers.get(),
                         spdy_settings_map.get(), alternative_service_map.get(),
                         server_network_stats_map.get())) {
       detected_corrupted_prefs = true;
     }
   } else {
     for (base::ListValue::const_iterator it = servers_list->begin();
          it != servers_list->end(); ++it) {
@@ skipping 462 matching lines @@
        it != network_stats_map.rend() &&
        count < kMaxServerNetworkStatsHostsToPersist;
        ++it, ++count) {
     server_network_stats_map->Put(it->first, it->second);
   }
 
   QuicServerInfoMap* quic_server_info_map = nullptr;
   const QuicServerInfoMap& main_quic_server_info_map =
       http_server_properties_impl_->quic_server_info_map();
   if (main_quic_server_info_map.size() > 0) {
-    quic_server_info_map = new QuicServerInfoMap(kMaxQuicServersToPersist);
+    quic_server_info_map =
+        new QuicServerInfoMap(max_server_configs_stored_in_properties());
     for (const std::pair<const QuicServerId, std::string>& entry :
          main_quic_server_info_map) {
       quic_server_info_map->Put(entry.first, entry.second);
     }
   }
 
   IPAddressNumber* last_quic_addr = new IPAddressNumber;
   http_server_properties_impl_->GetSupportsQuic(last_quic_addr);
   // Update the preferences on the pref thread.
   pref_task_runner_->PostTask(
@@ skipping 256 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net