SHP 5: Adding a new version for disk data, migrating disk data to use scheme/host/port representati…

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/single_thread_task_runner.h"
 #include "base/stl_util.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 = 4;
+const int kVersionNumber = 5;
 
 // 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 404 matching lines @@
   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": {
     //         "0-edge-chat.facebook.com:443" : {...},
     //         "0.client-channel.google.com:443" : {...},
-    //         "yt3.ggpht.com:443" : {...},
+    //         "yt3.ggpht.com:80" : {...},
     //         ...
     //      }, ...
     // },
     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.
+    // For Version 4, data was stored in the following format.
     // |servers| are saved in MRU order.
     //
     // "http_server_properties": {
     //      "servers": [
     //          {"yt3.ggpht.com:443" : {...}},
     //          {"0.client-channel.google.com:443" : {...}},
-    //          {"0-edge-chat.facebook.com:443" : {...}},
+    //          {"0-edge-chat.facebook.com:80" : {...}},
     //          ...
     //      ], ...
     // },
+    // For Version 5, data was stored in the following format.
+    // |servers| are saved in MRU order. |servers| are in the format flattened
+    // representation of (scheme/host/port) where port might be ignored if is
+    // default with scheme.
+    //
+    // "http_server_properties": {
+    //      "servers": [
+    //          {"https://yt3.ggpht.com" : {...}},
+    //          {"http://0.client-channel.google.com:443" : {...}},
+    //          {"http://0-edge-chat.facebook.com" : {...}},
+    //          ...
+    //      ], ...
+    // },
     if (!http_server_properties_dict.GetListWithoutPathExpansion(
             kServersKey, &servers_list)) {
       DVLOG(1) << "Malformed http_server_properties for servers list.";
       return;
     }
   }
 
   IPAddress* addr = new IPAddress;
   ReadSupportsQuic(http_server_properties_dict, addr);
 
   // String is "scheme://host:port" tuple of spdy server.
   std::unique_ptr<ServerList> spdy_servers(new ServerList);
   std::unique_ptr<SpdySettingsMap> spdy_settings_map(
       new SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
   std::unique_ptr<AlternativeServiceMap> alternative_service_map(
       new AlternativeServiceMap(kMaxAlternateProtocolHostsToPersist));
   std::unique_ptr<ServerNetworkStatsMap> server_network_stats_map(
       new ServerNetworkStatsMap(kMaxServerNetworkStatsHostsToPersist));
   std::unique_ptr<QuicServerInfoMap> quic_server_info_map(
       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())) {
+                        server_network_stats_map.get(), version)) {
       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())) {
+      if (!AddServersData(*servers_dict, spdy_servers.get(),
+                          spdy_settings_map.get(),
+                          alternative_service_map.get(),
+                          server_network_stats_map.get(), version)) {
         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(
           &HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread,
           base::Unretained(this), base::Owned(spdy_servers.release()),
           base::Owned(spdy_settings_map.release()),
           base::Owned(alternative_service_map.release()), base::Owned(addr),
           base::Owned(server_network_stats_map.release()),
           base::Owned(quic_server_info_map.release()),
           detected_corrupted_prefs));
 }
 
 bool HttpServerPropertiesManager::AddServersData(
     const base::DictionaryValue& servers_dict,
     ServerList* spdy_servers,
     SpdySettingsMap* spdy_settings_map,
     AlternativeServiceMap* alternative_service_map,
-    ServerNetworkStatsMap* network_stats_map) {
+    ServerNetworkStatsMap* network_stats_map,
+    int version) {
   for (base::DictionaryValue::Iterator it(servers_dict); !it.IsAtEnd();
        it.Advance()) {
-    // TODO(zhongyi): get server's scheme/host/port when servers_dict migrates
-    // to SchemeHostPort.
-    // Get server's host/pair.
+    // Get server's scheme/host/pair.
     const std::string& server_str = it.key();
-    // TODO(zhongyi): fill in the scheme field when servers_dict has scheme.
-    std::string spdy_server_url = "https://" + server_str;
+    std::string spdy_server_url = server_str;
+    if (version < 5) {
+      // For old version disk data, always use HTTPS as the scheme.
+      spdy_server_url.insert(0, "https://");
+    }
     url::SchemeHostPort spdy_server((GURL(spdy_server_url)));
     if (spdy_server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
       return false;
     }
 
     const base::DictionaryValue* server_pref_dict = nullptr;
     if (!it.value().GetAsDictionary(&server_pref_dict)) {
       DVLOG(1) << "Malformed http_server_properties server: " << server_str;
       return false;
@@ skipping 461 matching lines @@
 
 // All maps and lists are in MRU order.
 void HttpServerPropertiesManager::UpdatePrefsOnPrefThread(
     base::ListValue* spdy_server_list,
     SpdySettingsMap* spdy_settings_map,
     AlternativeServiceMap* alternative_service_map,
     IPAddress* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
     QuicServerInfoMap* quic_server_info_map,
     const base::Closure& completion) {
-  typedef base::MRUCache<HostPortPair, ServerPref> ServerPrefMap;
+  typedef base::MRUCache<url::SchemeHostPort, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map(ServerPrefMap::NO_AUTO_EVICT);
 
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
 
   // 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);
+    std::string server_str;
+    if (spdy_server_list->GetString(index - 1, &server_str)) {
+      url::SchemeHostPort server((GURL(server_str)));
       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 in the MRU order.
   for (SpdySettingsMap::reverse_iterator map_it = spdy_settings_map->rbegin();
        map_it != spdy_settings_map->rend(); ++map_it) {
-    // TODO(zhongyi): use memory data once disk data is migrated.
-    const url::SchemeHostPort spdy_server = map_it->first;
-    const HostPortPair server(spdy_server.host(), spdy_server.port());
+    const url::SchemeHostPort server = map_it->first;
     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 in the MRU order.
   for (AlternativeServiceMap::const_reverse_iterator map_it =
            alternative_service_map->rbegin();
        map_it != alternative_service_map->rend(); ++map_it) {
-    // TODO(zhongyi): migrate to SHP once server_pref_map is migrated.
-    const HostPortPair server(map_it->first.host(), map_it->first.port());
+    const url::SchemeHostPort 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 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) {
-    // TODO(zhongyi): use memory data once disk data is migrated.
-    const url::SchemeHostPort spdy_server = map_it->first;
-    const HostPortPair server(spdy_server.host(), spdy_server.port());
+    const url::SchemeHostPort server = map_it->first;
     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 prefs in the MRU order.
   base::DictionaryValue http_server_properties_dict;
   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 url::SchemeHostPort 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);
+    servers_dict->SetWithoutPathExpansion(server.Serialize(), server_pref_dict);
     bool value = servers_list->AppendIfNotPresent(servers_dict);
     DCHECK(value);  // Should never happen.
   }
 
   http_server_properties_dict.SetWithoutPathExpansion(kServersKey,
                                                       servers_list);
   SetVersion(&http_server_properties_dict, kVersionNumber);
 
   SaveSupportsQuicToPrefs(last_quic_address, &http_server_properties_dict);
 
@@ skipping 112 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net