SPDY - persist 300 most recently used servers that support SPDY to preferences file

chrome/browser/net/http_server_properties_manager.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 "chrome/browser/net/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
@@ skipping 31 matching lines @@
 const int kVersionNumber = 2;
 
 typedef std::vector<std::string> StringVector;
 
 // Persist 200 MRU AlternateProtocolHostPortPairs.
 const int kMaxAlternateProtocolHostsToPersist = 200;
 
 // Persist 200 MRU SpdySettingsHostPortPairs.
 const int kMaxSpdySettingsHostsToPersist = 200;
 
+// Persist 300 MRU SupportsSpdyServerHostPortPairs.
+const int kMaxSupportsSpdyServerHostsToPersist = 300;
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
     PrefService* pref_service)
     : pref_service_(pref_service),
       setting_prefs_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 70 matching lines @@
 }
 
 void HttpServerPropertiesManager::Clear(const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   http_server_properties_impl_->Clear();
   UpdatePrefsFromCacheOnIO(completion);
 }
 
 bool HttpServerPropertiesManager::SupportsSpdy(
-    const net::HostPortPair& server) const {
+    const net::HostPortPair& server) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->SupportsSpdy(server);
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(
     const net::HostPortPair& server,
     bool support_spdy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
@@ skipping 174 matching lines @@
 
   // The properties for a given server is in
   // http_server_properties_dict["servers"][server].
   const base::DictionaryValue* servers_dict = NULL;
   if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
       "servers", &servers_dict)) {
     DVLOG(1) << "Malformed http_server_properties for servers.";
     return;
   }
 
-  // TODO(rtenneti): Mark entries with an LRU sequence number (date of access?),
-  // and then truncate down deleting old stuff.
-  if (version != kVersionNumber && servers_dict->size() > 300) {
-    DVLOG(1) << "Size is too large. Clearing all properties.";
-    return;
-  }
-
   // String is host/port pair of spdy server.
   scoped_ptr<StringVector> spdy_servers(new StringVector);
   scoped_ptr<net::SpdySettingsMap> spdy_settings_map(
       new net::SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
   scoped_ptr<net::PipelineCapabilityMap> pipeline_capability_map(
       new net::PipelineCapabilityMap);
   scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
       new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist));
 
   for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
@@ skipping 171 matching lines @@
 // This is required so we can set this as the callback for a timer.
 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO() {
   UpdatePrefsFromCacheOnIO(base::Closure());
 }
 
 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO(
     const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::ListValue* spdy_server_list = new base::ListValue;
-  http_server_properties_impl_->GetSpdyServerList(spdy_server_list);
+  http_server_properties_impl_->GetSpdyServerList(
+      spdy_server_list, kMaxSupportsSpdyServerHostsToPersist);
 
   net::SpdySettingsMap* spdy_settings_map =
       new net::SpdySettingsMap(kMaxSpdySettingsHostsToPersist);
   const net::SpdySettingsMap& main_map =
       http_server_properties_impl_->spdy_settings_map();
   int count = 0;
   for (net::SpdySettingsMap::const_iterator it = main_map.begin();
        it != main_map.end() && count < kMaxSpdySettingsHostsToPersist;
        ++it, ++count) {
     spdy_settings_map->Put(it->first, it->second);
@@ skipping 52 matching lines @@
   net::HttpPipelinedHostCapability pipeline_capability;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnUI(
     base::ListValue* spdy_server_list,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
     net::PipelineCapabilityMap* pipeline_capability_map,
     const base::Closure& completion) {
 
-  // TODO(rtenneti): Fix ServerPrefMap to preserve MRU order of
-  // spdy_settings_map, alternate_protocol_map and pipeline_capability_map.
   typedef std::map<net::HostPortPair, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map;
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Add servers that support spdy to server_pref_map.
   std::string s;
   for (base::ListValue::const_iterator list_it = spdy_server_list->begin();
        list_it != spdy_server_list->end(); ++list_it) {
     if ((*list_it)->GetAsString(&s)) {
@@ skipping 65 matching lines @@
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   for (ServerPrefMap::const_iterator map_it =
        server_pref_map.begin();
        map_it != server_pref_map.end(); ++map_it) {
     const net::HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
     // Save supports_spdy.
-    server_pref_dict->SetBoolean("supports_spdy", server_pref.supports_spdy);
+    if (server_pref.supports_spdy)
+      server_pref_dict->SetBoolean("supports_spdy", server_pref.supports_spdy);
 
     // Save SPDY settings.
     if (server_pref.settings_map) {
       base::DictionaryValue* spdy_settings_dict = new base::DictionaryValue;
       for (net::SettingsMap::const_iterator it =
            server_pref.settings_map->begin();
            it != server_pref.settings_map->end(); ++it) {
         net::SpdySettingsIds id = it->first;
         uint32 value = it->second.second;
         std::string key = base::StringPrintf("%u", id);
@@ skipping 40 matching lines @@
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!setting_prefs_)
     ScheduleUpdateCacheOnUI();
 }
 
 }  // namespace chrome_browser_net