HttpServerProperties - maintain the MRU order (across browser sessions)

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 17 matching lines @@
 // Time to wait before starting an update the preferences from the
 // http_server_properties_impl_ cache. Scheduling another update during this
 // period will reset the timer.
 const int64_t kUpdatePrefsDelayMs = 60000;
 
 // "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 = 3;
+const int kVersionNumber = 4;
 
 // Persist 200 MRU AlternateProtocolHostPortPairs.
 const int kMaxAlternateProtocolHostsToPersist = 200;
 
 // Persist 200 MRU SpdySettingsHostPortPairs.
 const int kMaxSpdySettingsHostsToPersist = 200;
 
 // Persist 300 MRU SupportsSpdyServerHostPortPairs.
 const int kMaxSupportsSpdyServerHostsToPersist = 300;
 
@@ skipping 389 matching lines @@
   const base::DictionaryValue& http_server_properties_dict =
       *pref_service_->GetDictionary(path_);
 
   int version = kMissingVersion;
   if (!http_server_properties_dict.GetIntegerWithoutPathExpansion(kVersionKey,
                                                                   &version)) {
     DVLOG(1) << "Missing version. Clearing all properties.";
     return;
   }
 
-  // The properties for a given server is in
-  // http_server_properties_dict["servers"][server].
-  // Server data was stored in the following format in alphabetical order.
-  //
-  //   "http_server_properties": {
-  //      "servers": {
-  //         "accounts.google.com:443": {...},
-  //         "accounts.youtube.com:443": {...},
-  //         "android.clients.google.com:443": {...},
-  //          ...
-  //      }, ...
-  // },
   const base::DictionaryValue* servers_dict = NULL;
-  if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
-          kServersKey, &servers_dict)) {
-    DVLOG(1) << "Malformed http_server_properties for servers.";
-    return;
+  const base::ListValue* servers_list = NULL;
+  if (version < 4) {
+    // The properties for a given server is in
+    // http_server_properties_dict["servers"][server].
+    // Before Version 4, server data was stored in the following format in
+    // alphabetical order.
+    //
+    //   "http_server_properties": {
+    //      "servers": {
+    //         "accounts.google.com:443": {...},
+    //         "accounts.youtube.com:443": {...},
+    //         "android.clients.google.com:443": {...},
+    //          ...
+    //      }, ...
+    // },
+    if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
+            kServersKey, &servers_dict)) {
+      DVLOG(1) << "Malformed http_server_properties for servers.";
+      return;
+    }
+  } else {
+    // From Version 4 onwards, data was stored in the following format.
+    // servers were saved in MRU order.
+    //
+    // "http_server_properties": {
+    //      "servers": [
+    //          {"yt3.ggpht.com:443", {...}},
+    //          {"0.client-channel.google.com:443", {...}},
+    //          {"0-edge-chat.facebook.com:443", {...}},
+    //          ...
+    //      ], ...
+    // },
+    if (!http_server_properties_dict.GetListWithoutPathExpansion(
+            kServersKey, &servers_list)) {
+      DVLOG(1) << "Malformed http_server_properties for servers list.";
+      return;
+    }
   }
 
   IPAddressNumber* addr = new IPAddressNumber;
   ReadSupportsQuic(http_server_properties_dict, addr);
 
   // 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));
 
-  if (!AddServersData(*servers_dict, spdy_servers.get(),
-                      spdy_settings_map.get(), alternative_service_map.get(),
-                      server_network_stats_map.get())) {
-    detected_corrupted_prefs = true;
+  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) {
+      if (!(*it)->GetAsDictionary(&servers_dict)) {
+        DVLOG(1) << "Malformed http_server_properties for servers dictionary.";
+        detected_corrupted_prefs = true;
+        continue;
+      }
+      if (!AddServersData(
+              *servers_dict, spdy_servers.get(), spdy_settings_map.get(),
+              alternative_service_map.get(), server_network_stats_map.get())) {
+        detected_corrupted_prefs = true;
+      }
+    }
   }
 
   if (!AddToQuicServerInfoMap(http_server_properties_dict,
                               quic_server_info_map.get())) {
     detected_corrupted_prefs = true;
   }
 
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
@@ skipping 359 matching lines @@
 
 // This is required so we can set this as the callback for a timer.
 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread() {
   UpdatePrefsFromCacheOnNetworkThread(base::Closure());
 }
 
 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread(
     const base::Closure& completion) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
+  // It is in MRU order.
   base::ListValue* spdy_server_list = new base::ListValue;
   http_server_properties_impl_->GetSpdyServerList(
       spdy_server_list, kMaxSupportsSpdyServerHostsToPersist);
 
   SpdySettingsMap* spdy_settings_map =
       new SpdySettingsMap(kMaxSpdySettingsHostsToPersist);
   const SpdySettingsMap& main_map =
       http_server_properties_impl_->spdy_settings_map();
   int count = 0;
-  for (SpdySettingsMap::const_iterator it = main_map.begin();
-       it != main_map.end() && count < kMaxSpdySettingsHostsToPersist;
+  // Maintain MRU order.
+  for (SpdySettingsMap::const_reverse_iterator it = main_map.rbegin();
+       it != main_map.rend() && count < kMaxSpdySettingsHostsToPersist;
        ++it, ++count) {
     spdy_settings_map->Put(it->first, it->second);
   }
 
   AlternativeServiceMap* alternative_service_map =
       new AlternativeServiceMap(kMaxAlternateProtocolHostsToPersist);
   const AlternativeServiceMap& map =
       http_server_properties_impl_->alternative_service_map();
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers.Memory",
                        map.size());
   count = 0;
   typedef std::map<std::string, bool> CanonicalHostPersistedMap;
   CanonicalHostPersistedMap persisted_map;
-  for (AlternativeServiceMap::const_iterator it = map.begin();
-       it != map.end() && count < kMaxAlternateProtocolHostsToPersist; ++it) {
+  // Maintain MRU order.
+  for (AlternativeServiceMap::const_reverse_iterator it = map.rbegin();
+       it != map.rend() && count < kMaxAlternateProtocolHostsToPersist; ++it) {
     const HostPortPair& server = it->first;
     AlternativeServiceInfoVector notbroken_alternative_service_info_vector;
     for (const AlternativeServiceInfo& alternative_service_info : it->second) {
       // Do not persist expired entries.
       if (alternative_service_info.expiration < base::Time::Now()) {
         continue;
       }
       AlternativeService alternative_service(
           alternative_service_info.alternative_service);
       if (!IsAlternateProtocolValid(alternative_service.protocol)) {
@@ skipping 21 matching lines @@
     alternative_service_map->Put(server,
                                  notbroken_alternative_service_info_vector);
     ++count;
   }
 
   ServerNetworkStatsMap* server_network_stats_map =
       new ServerNetworkStatsMap(kMaxServerNetworkStatsHostsToPersist);
   const ServerNetworkStatsMap& network_stats_map =
       http_server_properties_impl_->server_network_stats_map();
   count = 0;
-  for (ServerNetworkStatsMap::const_iterator it = network_stats_map.begin();
-       it != network_stats_map.end() &&
+  for (ServerNetworkStatsMap::const_reverse_iterator
+           it = network_stats_map.rbegin();
+       it != network_stats_map.rend() &&
        count < kMaxServerNetworkStatsHostsToPersist;
        ++it, ++count) {
     server_network_stats_map->Put(it->first, it->second);
   }
 
   QuicServerInfoMap* quic_server_info_map = NULL;
   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);
@@ skipping 37 matching lines @@
         alternative_service_info_vector(alternative_service_info_vector),
         supports_quic(supports_quic),
         server_network_stats(server_network_stats) {}
   bool supports_spdy;
   const SettingsMap* settings_map;
   const AlternativeServiceInfoVector* alternative_service_info_vector;
   const SupportsQuic* supports_quic;
   const ServerNetworkStats* server_network_stats;
 };
 
+// All maps and lists are in MRU order.
 void HttpServerPropertiesManager::UpdatePrefsOnPrefThread(
     base::ListValue* spdy_server_list,
     SpdySettingsMap* spdy_settings_map,
     AlternativeServiceMap* alternative_service_map,
     IPAddressNumber* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
     QuicServerInfoMap* quic_server_info_map,
     const base::Closure& completion) {
-  typedef std::map<HostPortPair, ServerPref> ServerPrefMap;
-  ServerPrefMap server_pref_map;
+  typedef base::MRUCache<HostPortPair, ServerPref> ServerPrefMap;
+  ServerPrefMap server_pref_map(ServerPrefMap::NO_AUTO_EVICT);
 
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
 
-  // 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)) {
+  // Add servers that support spdy to server_pref_map in the MRU order.
+  for (size_t index = spdy_server_list->GetSize(); index > 0; --index) {
+    std::string s;
+    if (spdy_server_list->GetString(index - 1, &s)) {
       HostPortPair server = HostPortPair::FromString(s);
-      server_pref_map[server].supports_spdy = true;
+      ServerPrefMap::iterator it = server_pref_map.Get(server);
+      if (it == server_pref_map.end()) {
+        ServerPref server_pref;
+        server_pref.supports_spdy = true;
+        server_pref_map.Put(server, server_pref);
+      } else {
+        it->second.supports_spdy = true;
+      }
     }
   }
 
-  // Add servers that have SpdySettings to server_pref_map.
-  for (SpdySettingsMap::iterator map_it = spdy_settings_map->begin();
-       map_it != spdy_settings_map->end(); ++map_it) {
+  // Add servers that have SpdySettings to server_pref_map in the MRU order.
+  for (SpdySettingsMap::reverse_iterator map_it = spdy_settings_map->rbegin();
+       map_it != spdy_settings_map->rend(); ++map_it) {
     const HostPortPair& server = map_it->first;
-    server_pref_map[server].settings_map = &map_it->second;
+    ServerPrefMap::iterator it = server_pref_map.Get(server);
+    if (it == server_pref_map.end()) {
+      ServerPref server_pref;
+      server_pref.settings_map = &map_it->second;
+      server_pref_map.Put(server, server_pref);
+    } else {
+      it->second.settings_map = &map_it->second;
+    }
   }
 
-  // Add alternative services to server_pref_map.
-  for (AlternativeServiceMap::const_iterator map_it =
-           alternative_service_map->begin();
-       map_it != alternative_service_map->end(); ++map_it) {
-    server_pref_map[map_it->first].alternative_service_info_vector =
-        &map_it->second;
+  // Add alternative services to server_pref_map in the MRU order.
+  for (AlternativeServiceMap::const_reverse_iterator map_it =
+           alternative_service_map->rbegin();
+       map_it != alternative_service_map->rend(); ++map_it) {
+    const HostPortPair& server = map_it->first;
+    ServerPrefMap::iterator it = server_pref_map.Get(server);
+    if (it == server_pref_map.end()) {
+      ServerPref server_pref;
+      server_pref.alternative_service_info_vector = &map_it->second;
+      server_pref_map.Put(server, server_pref);
+    } else {
+      it->second.alternative_service_info_vector = &map_it->second;
+    }
   }
 
-  // Add ServerNetworkStats servers to server_pref_map.
-  for (ServerNetworkStatsMap::const_iterator map_it =
-           server_network_stats_map->begin();
-       map_it != server_network_stats_map->end(); ++map_it) {
+  // Add ServerNetworkStats servers to server_pref_map in the MRU order.
+  for (ServerNetworkStatsMap::const_reverse_iterator map_it =
+           server_network_stats_map->rbegin();
+       map_it != server_network_stats_map->rend(); ++map_it) {
     const HostPortPair& server = map_it->first;
-    server_pref_map[server].server_network_stats = &map_it->second;
+    ServerPrefMap::iterator it = server_pref_map.Get(server);
+    if (it == server_pref_map.end()) {
+      ServerPref server_pref;
+      server_pref.server_network_stats = &map_it->second;
+      server_pref_map.Put(server, server_pref);
+    } else {
+      it->second.server_network_stats = &map_it->second;
+    }
   }
 
-  // Persist properties to the |path_|.
+  // Persist properties to the |path_| in the MRU order.
   base::DictionaryValue http_server_properties_dict;
-  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) {
+  base::ListValue* servers_list = new base::ListValue;
+  for (ServerPrefMap::const_reverse_iterator map_it = server_pref_map.rbegin();
+       map_it != server_pref_map.rend(); ++map_it) {
     const HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
+    base::DictionaryValue* servers_dict = new base::DictionaryValue;
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
     // Save supports_spdy.
     if (server_pref.supports_spdy)
       server_pref_dict->SetBoolean(kSupportsSpdyKey, server_pref.supports_spdy);
     SaveSpdySettingsToServerPrefs(server_pref.settings_map, server_pref_dict);
     SaveAlternativeServiceToServerPrefs(
         server_pref.alternative_service_info_vector, server_pref_dict);
     SaveNetworkStatsToServerPrefs(server_pref.server_network_stats,
                                   server_pref_dict);
 
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
+    bool value = servers_list->AppendIfNotPresent(servers_dict);
+    DCHECK(value);  // Should never happen.
   }
 
   http_server_properties_dict.SetWithoutPathExpansion(kServersKey,
-                                                      servers_dict);
+                                                      servers_list);
   SetVersion(&http_server_properties_dict, kVersionNumber);
 
   SaveSupportsQuicToPrefs(last_quic_address, &http_server_properties_dict);
 
   SaveQuicServerInfoMapToServerPrefs(quic_server_info_map,
                                      &http_server_properties_dict);
 
   setting_prefs_ = true;
   pref_service_->Set(path_, http_server_properties_dict);
   setting_prefs_ = false;
@@ skipping 108 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net