Make HttpServerProperties::GetSupportsQuic not host-specific.

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.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 264 matching lines @@
   http_server_properties_impl_->ClearAllSpdySettings();
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 const SpdySettingsMap& HttpServerPropertiesManager::spdy_settings_map()
     const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->spdy_settings_map();
 }
 
-SupportsQuic HttpServerPropertiesManager::GetSupportsQuic(
-    const HostPortPair& host_port_pair) const {
+bool HttpServerPropertiesManager::GetSupportsQuic(
+    IPAddressNumber* last_address) const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetSupportsQuic(host_port_pair);
+  return http_server_properties_impl_->GetSupportsQuic(last_address);
 }
 
 void HttpServerPropertiesManager::SetSupportsQuic(
-    const HostPortPair& host_port_pair,
     bool used_quic,
-    const std::string& address) {
+    const IPAddressNumber& address) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->SetSupportsQuic(
-      host_port_pair, used_quic, address);
+  http_server_properties_impl_->SetSupportsQuic(used_quic, address);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
-const SupportsQuicMap& HttpServerPropertiesManager::supports_quic_map()
-    const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->supports_quic_map();
-}
-
 void HttpServerPropertiesManager::SetServerNetworkStats(
     const HostPortPair& host_port_pair,
     ServerNetworkStats stats) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetServerNetworkStats(host_port_pair, stats);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 const ServerNetworkStats* HttpServerPropertiesManager::GetServerNetworkStats(
     const HostPortPair& host_port_pair) {
@@ skipping 48 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(
           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<SpdySettingsMap> spdy_settings_map(
       new SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
   scoped_ptr<AlternateProtocolMap> alternate_protocol_map(
       new AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist));
-  scoped_ptr<SupportsQuicMap> supports_quic_map(new SupportsQuicMap());
   scoped_ptr<ServerNetworkStatsMap> server_network_stats_map(
       new ServerNetworkStatsMap(kMaxServerNetworkStatsHostsToPersist));
 
   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;
@@ skipping 11 matching lines @@
     // 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());
     if (!AddToAlternateProtocolMap(server, *server_pref_dict,
                                    alternate_protocol_map.get()) ||
-        !AddToSupportsQuicMap(server, *server_pref_dict,
-                              supports_quic_map.get()) ||
         !AddToNetworkStatsMap(server, *server_pref_dict,
                               server_network_stats_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(alternate_protocol_map.release()),
-          base::Owned(supports_quic_map.release()),
+          base::Owned(alternate_protocol_map.release()), base::Owned(addr),
           base::Owned(server_network_stats_map.release()),
           detected_corrupted_prefs));
 }
 
 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());
@@ skipping 62 matching lines @@
     DVLOG(1) << "Malformed Alternate-Protocol server: " << server.ToString();
     return false;
   }
 
   AlternateProtocolInfo port_alternate_protocol(static_cast<uint16>(port),
                                                 protocol, probability);
   alternate_protocol_map->Put(server, port_alternate_protocol);
   return true;
 }
 
-bool HttpServerPropertiesManager::AddToSupportsQuicMap(
-    const HostPortPair& server,
-    const base::DictionaryValue& server_pref_dict,
-    SupportsQuicMap* supports_quic_map) {
-  DCHECK(supports_quic_map->find(server) == supports_quic_map->end());
+bool HttpServerPropertiesManager::ReadSupportsQuic(
+    const base::DictionaryValue& http_server_properties_dict,
+    IPAddressNumber* last_quic_address) {
   const base::DictionaryValue* supports_quic_dict = NULL;
-  if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
+  if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
           kSupportsQuicKey, &supports_quic_dict)) {
     return true;
   }
-  bool used_quic = 0;
+  bool used_quic = false;
   if (!supports_quic_dict->GetBooleanWithoutPathExpansion(kUsedQuicKey,
                                                           &used_quic)) {
-    DVLOG(1) << "Malformed SupportsQuic server: " << server.ToString();
+    DVLOG(1) << "Malformed SupportsQuic";
     return false;
   }
+  if (!used_quic)
+    return false;
+
   std::string address;
   if (!supports_quic_dict->GetStringWithoutPathExpansion(kAddressKey,
-                                                         &address)) {
-    DVLOG(1) << "Malformed SupportsQuic server: " << server.ToString();
+                                                         &address) ||
+      !ParseIPLiteralToNumber(address, last_quic_address)) {
+    DVLOG(1) << "Malformed SupportsQuic";
     return false;
   }
-  SupportsQuic supports_quic(used_quic, address);
-  supports_quic_map->insert(std::make_pair(server, supports_quic));
   return true;
 }
 
 bool HttpServerPropertiesManager::AddToNetworkStatsMap(
     const HostPortPair& server,
     const base::DictionaryValue& server_pref_dict,
     ServerNetworkStatsMap* network_stats_map) {
   DCHECK(network_stats_map->Peek(server) == network_stats_map->end());
   const base::DictionaryValue* server_network_stats_dict = NULL;
   if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
@@ skipping 12 matching lines @@
   // TODO(rtenneti): When QUIC starts using bandwidth_estimate, then persist
   // bandwidth_estimate.
   network_stats_map->Put(server, server_network_stats);
   return true;
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread(
     StringVector* spdy_servers,
     SpdySettingsMap* spdy_settings_map,
     AlternateProtocolMap* alternate_protocol_map,
-    SupportsQuicMap* supports_quic_map,
+    IPAddressNumber* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_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());
 
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdyServers", spdy_servers->size());
   http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
 
   // Update the cached data and use the new spdy_settings from preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdySettings", spdy_settings_map->size());
   http_server_properties_impl_->InitializeSpdySettingsServers(
       spdy_settings_map);
 
   // Update the cached data and use the new Alternate-Protocol server list from
   // preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers",
                        alternate_protocol_map->size());
   http_server_properties_impl_->InitializeAlternateProtocolServers(
       alternate_protocol_map);
 
-  http_server_properties_impl_->InitializeSupportsQuic(supports_quic_map);
+  http_server_properties_impl_->InitializeSupportsQuic(last_quic_address);
 
   http_server_properties_impl_->InitializeServerNetworkStats(
       server_network_stats_map);
 
   // Update the prefs with what we have read (delete all corrupted prefs).
   if (detected_corrupted_prefs)
     ScheduleUpdatePrefsOnNetworkThread();
 }
 
 //
@@ skipping 56 matching lines @@
         http_server_properties_impl_->GetCanonicalSuffix(server.host());
     if (!canonical_suffix.empty()) {
       if (persisted_map.find(canonical_suffix) != persisted_map.end())
         continue;
       persisted_map[canonical_suffix] = true;
     }
     alternate_protocol_map->Put(server, it->second);
     ++count;
   }
 
-  SupportsQuicMap* supports_quic_map = new SupportsQuicMap();
-  const SupportsQuicMap& main_supports_quic_map =
-      http_server_properties_impl_->supports_quic_map();
-  for (SupportsQuicMap::const_iterator it = main_supports_quic_map.begin();
-       it != main_supports_quic_map.end(); ++it) {
-    supports_quic_map->insert(std::make_pair(it->first, it->second));
-  }
-
   ServerNetworkStatsMap* server_network_stats_map =
       new ServerNetworkStatsMap(kMaxServerNetworkStatsHostsToPersist);
   const ServerNetworkStatsMap& main_server_network_stats_map =
       http_server_properties_impl_->server_network_stats_map();
   for (ServerNetworkStatsMap::const_iterator it =
            main_server_network_stats_map.begin();
        it != main_server_network_stats_map.end(); ++it) {
     server_network_stats_map->Put(it->first, it->second);
   }
 
+  IPAddressNumber* last_quic_addr = new IPAddressNumber;
+  http_server_properties_impl_->GetSupportsQuic(last_quic_addr);
   // Update the preferences on the pref thread.
   pref_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesManager::UpdatePrefsOnPrefThread, pref_weak_ptr_,
           base::Owned(spdy_server_list), base::Owned(spdy_settings_map),
-          base::Owned(alternate_protocol_map), base::Owned(supports_quic_map),
+          base::Owned(alternate_protocol_map), base::Owned(last_quic_addr),
           base::Owned(server_network_stats_map), completion));
 }
 
 // A local or temporary data structure to hold |supports_spdy|, SpdySettings,
 // AlternateProtocolInfo and SupportsQuic preferences for a server. This is used
 // only in UpdatePrefsOnPrefThread.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
         settings_map(NULL),
@@ skipping 14 matching lines @@
   const SettingsMap* settings_map;
   const AlternateProtocolInfo* alternate_protocol;
   const SupportsQuic* supports_quic;
   const ServerNetworkStats* server_network_stats;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnPrefThread(
     base::ListValue* spdy_server_list,
     SpdySettingsMap* spdy_settings_map,
     AlternateProtocolMap* alternate_protocol_map,
-    SupportsQuicMap* supports_quic_map,
+    IPAddressNumber* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
     const base::Closure& completion) {
   typedef std::map<HostPortPair, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map;
 
   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();
@@ skipping 18 matching lines @@
        map_it != alternate_protocol_map->end(); ++map_it) {
     const HostPortPair& server = map_it->first;
     const AlternateProtocolInfo& port_alternate_protocol = map_it->second;
     if (!IsAlternateProtocolValid(port_alternate_protocol.protocol)) {
       continue;
     }
     server_pref_map[server].alternate_protocol = &map_it->second;
   }
 
   // Add SupportsQuic servers to server_pref_map.
+  /*
   for (SupportsQuicMap::const_iterator map_it = supports_quic_map->begin();
        map_it != supports_quic_map->end(); ++map_it) {
     const HostPortPair& server = map_it->first;
     server_pref_map[server].supports_quic = &map_it->second;
   }
+  */

[ramant (doing other things), 2015/02/03 18:09:37]

nit: could lines 747-755 be deleted.

[Ryan Hamilton, 2015/02/03 22:50:45]

Done.

 
   // 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) {
     const HostPortPair& server = map_it->first;
     server_pref_map[server].server_network_stats = &map_it->second;
   }
 
   // Persist properties to the |path_|.
   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) {
     const HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     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);
     SaveAlternateProtocolToServerPrefs(server_pref.alternate_protocol,
                                        server_pref_dict);
-    SaveSupportsQuicToServerPrefs(server_pref.supports_quic, server_pref_dict);
     SaveNetworkStatsToServerPrefs(server_pref.server_network_stats,
                                   server_pref_dict);
 
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
   }
 
   http_server_properties_dict.SetWithoutPathExpansion(kServersKey,
                                                       servers_dict);
   SetVersion(&http_server_properties_dict, kVersionNumber);
+
+  SaveSupportsQuicToPrefs(last_quic_address, &http_server_properties_dict);
+
   setting_prefs_ = true;
   pref_service_->Set(path_, http_server_properties_dict);
   setting_prefs_ = false;
 
   // Note that |completion| will be fired after we have written everything to
   // the Preferences, but likely before these changes are serialized to disk.
   // This is not a problem though, as JSONPrefStore guarantees that this will
   // happen, pretty soon, and even in the case we shut down immediately.
   if (!completion.is_null())
     completion.Run();
@@ skipping 28 matching lines @@
                                            port_alternate_protocol->port);
   const char* protocol_str =
       AlternateProtocolToString(port_alternate_protocol->protocol);
   port_alternate_protocol_dict->SetString(kProtocolKey, protocol_str);
   port_alternate_protocol_dict->SetDouble(kProbabilityKey,
                                           port_alternate_protocol->probability);
   server_pref_dict->SetWithoutPathExpansion(kAlternateProtocolKey,
                                             port_alternate_protocol_dict);
 }
 
-void HttpServerPropertiesManager::SaveSupportsQuicToServerPrefs(
-    const SupportsQuic* supports_quic,
-    base::DictionaryValue* server_pref_dict) {
-  // Save supports_quic.
-  if (!supports_quic)
+void HttpServerPropertiesManager::SaveSupportsQuicToPrefs(
+    const IPAddressNumber* last_quic_address,
+    base::DictionaryValue* http_server_properties_dict) {
+  if (!last_quic_address || last_quic_address->empty())
     return;
 
   base::DictionaryValue* supports_quic_dict = new base::DictionaryValue;
-  supports_quic_dict->SetBoolean(kUsedQuicKey, supports_quic->used_quic);
-  supports_quic_dict->SetString(kAddressKey, supports_quic->address);
-  server_pref_dict->SetWithoutPathExpansion(kSupportsQuicKey,
-                                            supports_quic_dict);
+  supports_quic_dict->SetBoolean(kUsedQuicKey, true);
+  supports_quic_dict->SetString(kAddressKey,
+                                IPAddressToString(*last_quic_address));
+  http_server_properties_dict->SetWithoutPathExpansion(kSupportsQuicKey,
+                                                       supports_quic_dict);
 }
 
 void HttpServerPropertiesManager::SaveNetworkStatsToServerPrefs(
     const ServerNetworkStats* server_network_stats,
     base::DictionaryValue* server_pref_dict) {
   if (!server_network_stats)
     return;
 
   base::DictionaryValue* server_network_stats_dict = new base::DictionaryValue;
   // Becasue JSON doesn't support int64, persist int64 as a string.
   server_network_stats_dict->SetInteger(
       kSrttKey, static_cast<int>(server_network_stats->srtt.ToInternalValue()));
   // TODO(rtenneti): When QUIC starts using bandwidth_estimate, then persist
   // bandwidth_estimate.
   server_pref_dict->SetWithoutPathExpansion(kNetworkStatsKey,
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net