Relanding 255326 "HttpServerProperties - Implement MRU for AlternateProtocolMap. Persist"

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 25 matching lines @@
 
 // "version" 0 indicates, http_server_properties doesn't have "version"
 // property.
 const int kMissingVersion = 0;
 
 // The version number of persisted http_server_properties.
 const int kVersionNumber = 2;
 
 typedef std::vector<std::string> StringVector;
 
+// Persist 200 MRU AlternateProtocolHostPortPairs.
+const int kMaxAlternateProtocolHostsToPersist = 200;
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
     PrefService* pref_service)
     : pref_service_(pref_service),
       setting_prefs_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 85 matching lines @@
 void HttpServerPropertiesManager::SetSupportsSpdy(
     const net::HostPortPair& server,
     bool support_spdy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   ScheduleUpdatePrefsOnIO();
 }
 
 bool HttpServerPropertiesManager::HasAlternateProtocol(
-    const net::HostPortPair& server) const {
+    const net::HostPortPair& server) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->HasAlternateProtocol(server);
 }
 
 net::PortAlternateProtocolPair
 HttpServerPropertiesManager::GetAlternateProtocol(
-    const net::HostPortPair& server) const {
+    const net::HostPortPair& server) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->GetAlternateProtocol(server);
 }
 
 void HttpServerPropertiesManager::SetAlternateProtocol(
     const net::HostPortPair& server,
     uint16 alternate_port,
     net::AlternateProtocol alternate_protocol) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   http_server_properties_impl_->SetAlternateProtocol(
@@ skipping 151 matching lines @@
     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);
   scoped_ptr<net::PipelineCapabilityMap> pipeline_capability_map(
       new net::PipelineCapabilityMap);
   scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
-      new net::AlternateProtocolMap);
+      new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist));
 
   for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
        it.Advance()) {
     // Get server's host/pair.
     const std::string& server_str = it.key();
     net::HostPortPair server = net::HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
       detected_corrupted_prefs = true;
       continue;
@@ skipping 45 matching lines @@
 
     int pipeline_capability = net::PIPELINE_UNKNOWN;
     if ((server_pref_dict->GetInteger(
          "pipeline_capability", &pipeline_capability)) &&
         pipeline_capability != net::PIPELINE_UNKNOWN) {
       (*pipeline_capability_map)[server] =
           static_cast<net::HttpPipelinedHostCapability>(pipeline_capability);
     }
 
     // Get alternate_protocol server.
-    DCHECK(!ContainsKey(*alternate_protocol_map, server));
+    DCHECK(alternate_protocol_map->Peek(server) ==
+           alternate_protocol_map->end());
     const base::DictionaryValue* port_alternate_protocol_dict = NULL;
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
         "alternate_protocol", &port_alternate_protocol_dict)) {
       continue;
     }
 
     do {
       int port = 0;
       if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
           "port", &port) || (port > (1 << 16))) {
@@ skipping 13 matching lines @@
       if (!net::IsAlternateProtocolValid(protocol)) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
       }
 
       net::PortAlternateProtocolPair port_alternate_protocol;
       port_alternate_protocol.port = port;
       port_alternate_protocol.protocol = protocol;
 
-      (*alternate_protocol_map)[server] = port_alternate_protocol;
+      alternate_protocol_map->Put(server, port_alternate_protocol);
     } while (false);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::
                  UpdateCacheFromPrefsOnIO,
                  base::Unretained(this),
                  base::Owned(spdy_servers.release()),
@@ skipping 68 matching lines @@
     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);
 
   net::SpdySettingsMap* spdy_settings_map = new net::SpdySettingsMap;
   *spdy_settings_map = http_server_properties_impl_->spdy_settings_map();
 
   net::AlternateProtocolMap* alternate_protocol_map =
-      new net::AlternateProtocolMap;
-  *alternate_protocol_map =
+      new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist);
+  const net::AlternateProtocolMap& map =
       http_server_properties_impl_->alternate_protocol_map();
+  int count = 0;
+  for (net::AlternateProtocolMap::const_iterator it = map.begin();
+       it != map.end() && count < kMaxAlternateProtocolHostsToPersist;
+       ++it, ++count) {
+    alternate_protocol_map->Put(it->first, it->second);
+  }
 
   net::PipelineCapabilityMap* pipeline_capability_map =
       new net::PipelineCapabilityMap;
   *pipeline_capability_map =
       http_server_properties_impl_->GetPipelineCapabilityMap();
 
   // Update the preferences on the UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
@@ skipping 30 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
+  // 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)) {
       net::HostPortPair server = net::HostPortPair::FromString(s);
 
       ServerPrefMap::iterator it = server_pref_map.find(server);
       if (it == server_pref_map.end()) {
         ServerPref server_pref(true, NULL, NULL);
         server_pref_map[server] = server_pref;
       } else {
         it->second.supports_spdy = true;
       }
     }
   }
 
   // Add servers that have SpdySettings to server_pref_map.
-  for (net::SpdySettingsMap::iterator map_it =
-       spdy_settings_map->begin();
+  for (net::SpdySettingsMap::iterator map_it = spdy_settings_map->begin();
        map_it != spdy_settings_map->end(); ++map_it) {
     const net::HostPortPair& server = map_it->first;
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
       ServerPref server_pref(false, &map_it->second, NULL);
       server_pref_map[server] = server_pref;
     } else {
       it->second.settings_map = &map_it->second;
     }
   }
 
   // Add AlternateProtocol servers to server_pref_map.
   for (net::AlternateProtocolMap::const_iterator map_it =
-       alternate_protocol_map->begin();
+           alternate_protocol_map->begin();
        map_it != alternate_protocol_map->end(); ++map_it) {
     const net::HostPortPair& server = map_it->first;
     const net::PortAlternateProtocolPair& port_alternate_protocol =
         map_it->second;
     if (!net::IsAlternateProtocolValid(port_alternate_protocol.protocol)) {
       continue;
     }
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
@@ skipping 87 matching lines @@
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!setting_prefs_)
     ScheduleUpdateCacheOnUI();
 }
 
 }  // namespace chrome_browser_net