HttpServerProperties - Minor reorganization of code in preperation of

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 19 matching lines @@
 // 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;
 
-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;
 
 // Persist 200 ServerNetworkStats.
@@ skipping 390 matching lines @@
 
   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;
   }
 
   IPAddressNumber* addr = new IPAddressNumber;
   ReadSupportsQuic(http_server_properties_dict, addr);
 
   // String is host/port pair of spdy server.
-  scoped_ptr<StringVector> spdy_servers(new StringVector);
+  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));
 
-  for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
+  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(
+          &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) {
+  for (base::DictionaryValue::Iterator it(servers_dict); !it.IsAtEnd();
        it.Advance()) {
     // Get server's host/pair.
     const std::string& server_str = it.key();
     HostPortPair server = HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
-      detected_corrupted_prefs = true;
-      continue;
+      return false;
     }
 
     const base::DictionaryValue* server_pref_dict = NULL;
     if (!it.value().GetAsDictionary(&server_pref_dict)) {
       DVLOG(1) << "Malformed http_server_properties server: " << server_str;
-      detected_corrupted_prefs = true;
-      continue;
+      return false;
     }
 
     // Get if server supports Spdy.
     bool supports_spdy = false;
     if ((server_pref_dict->GetBoolean(kSupportsSpdyKey, &supports_spdy)) &&
         supports_spdy) {
       spdy_servers->push_back(server_str);
     }
 
-    AddToSpdySettingsMap(server, *server_pref_dict, spdy_settings_map.get());
+    AddToSpdySettingsMap(server, *server_pref_dict, spdy_settings_map);
     if (!AddToAlternativeServiceMap(server, *server_pref_dict,
-                                    alternative_service_map.get()) ||
-        !AddToNetworkStatsMap(server, *server_pref_dict,
-                              server_network_stats_map.get())) {
-      detected_corrupted_prefs = true;
+                                    alternative_service_map) ||
+        !AddToNetworkStatsMap(server, *server_pref_dict, network_stats_map)) {
+      return false;
     }
   }
-
-  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));
+  return true;
 }
 
 void HttpServerPropertiesManager::AddToSpdySettingsMap(
     const HostPortPair& server,
     const base::DictionaryValue& server_pref_dict,
     SpdySettingsMap* spdy_settings_map) {
   // Get SpdySettings.
   DCHECK(spdy_settings_map->Peek(server) == spdy_settings_map->end());
   const base::DictionaryValue* spdy_settings_dict = NULL;
   if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
@@ skipping 229 matching lines @@
                << quic_server_id_str;
       detected_corrupted_prefs = true;
       continue;
     }
     quic_server_info_map->Put(quic_server_id, quic_server_info);
   }
   return !detected_corrupted_prefs;
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread(
-    StringVector* spdy_servers,
+    ServerList* spdy_servers,
     SpdySettingsMap* spdy_settings_map,
     AlternativeServiceMap* alternative_service_map,
     IPAddressNumber* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
     QuicServerInfoMap* quic_server_info_map,
     bool detected_corrupted_prefs) {
   // Preferences have the master data because admins might have pushed new
   // preferences. Update the cached data with new data from preferences.
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 379 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net