SHP 2: Change SpdySettingsMap to use SchemeHostPort as the key. No change to Pref data.

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 271 matching lines @@
   return http_server_properties_impl_->alternative_service_map();
 }
 
 std::unique_ptr<base::Value>
 HttpServerPropertiesManager::GetAlternativeServiceInfoAsValue() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetAlternativeServiceInfoAsValue();
 }
 
 const SettingsMap& HttpServerPropertiesManager::GetSpdySettings(
-    const HostPortPair& host_port_pair) {
+    const url::SchemeHostPort& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetSpdySettings(host_port_pair);
+  return http_server_properties_impl_->GetSpdySettings(server);
 }
 
 bool HttpServerPropertiesManager::SetSpdySetting(
-    const HostPortPair& host_port_pair,
+    const url::SchemeHostPort& server,
     SpdySettingsIds id,
     SpdySettingsFlags flags,
     uint32_t value) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  bool persist = http_server_properties_impl_->SetSpdySetting(
-      host_port_pair, id, flags, value);
+  bool persist =
+      http_server_properties_impl_->SetSpdySetting(server, id, flags, value);
   if (persist)
     ScheduleUpdatePrefsOnNetworkThread(SET_SPDY_SETTING);
   return persist;
 }
 
 void HttpServerPropertiesManager::ClearSpdySettings(
-    const HostPortPair& host_port_pair) {
+    const url::SchemeHostPort& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->ClearSpdySettings(host_port_pair);
+  http_server_properties_impl_->ClearSpdySettings(server);
   ScheduleUpdatePrefsOnNetworkThread(CLEAR_SPDY_SETTINGS);
 }
 
 void HttpServerPropertiesManager::ClearAllSpdySettings() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->ClearAllSpdySettings();
   ScheduleUpdatePrefsOnNetworkThread(CLEAR_ALL_SPDY_SETTINGS);
 }
 
 const SpdySettingsMap& HttpServerPropertiesManager::spdy_settings_map()
@@ skipping 223 matching lines @@
     SpdySettingsMap* spdy_settings_map,
     AlternativeServiceMap* alternative_service_map,
     ServerNetworkStatsMap* network_stats_map) {
   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.
     const std::string& server_str = it.key();
     HostPortPair server = HostPortPair::FromString(server_str);
+    // TODO(zhongyi): fill in the scheme field when servers_dict has scheme.
+    std::string spdy_server_url = "https://" + server_str;
+    url::SchemeHostPort spdy_server((GURL(spdy_server_url)));
     if (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;
     }
 
     // Get if server supports Spdy.
     bool supports_spdy = false;
     if ((server_pref_dict->GetBoolean(kSupportsSpdyKey, &supports_spdy)) &&
         supports_spdy) {
-      // TODO(zhongyi): fill in the scheme field when servers_dict has scheme.
-      std::string spdy_server_url = "https://" + server_str;
-      url::SchemeHostPort spdy_server((GURL(spdy_server_url)));
       spdy_servers->push_back(spdy_server.Serialize());
     }
 
-    AddToSpdySettingsMap(server, *server_pref_dict, spdy_settings_map);
+    AddToSpdySettingsMap(spdy_server, *server_pref_dict, spdy_settings_map);
     if (!AddToAlternativeServiceMap(server, *server_pref_dict,
                                     alternative_service_map) ||
         !AddToNetworkStatsMap(server, *server_pref_dict, network_stats_map)) {
       return false;
     }
   }
   return true;
 }
 
 void HttpServerPropertiesManager::AddToSpdySettingsMap(
-    const HostPortPair& server,
+    const url::SchemeHostPort& 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 = nullptr;
   if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
           kSettingsKey, &spdy_settings_dict)) {
     return;
   }
   SettingsMap settings_map;
   for (base::DictionaryValue::Iterator dict_it(*spdy_settings_dict);
        !dict_it.IsAtEnd(); dict_it.Advance()) {
     const std::string& id_str = dict_it.key();
     int id = 0;
     if (!base::StringToInt(id_str, &id)) {
       DVLOG(1) << "Malformed id in SpdySettings for server: "
-               << server.ToString();
+               << server.Serialize();
       NOTREACHED();
       continue;
     }
     int value = 0;
     if (!dict_it.value().GetAsInteger(&value)) {
       DVLOG(1) << "Malformed value in SpdySettings for server: "
-               << server.ToString();
+               << server.Serialize();
       NOTREACHED();
       continue;
     }
     SettingsFlagsAndValue flags_and_value(SETTINGS_FLAG_PERSISTED, value);
     settings_map[static_cast<SpdySettingsIds>(id)] = flags_and_value;
   }
   spdy_settings_map->Put(server, settings_map);
 }
 
 bool HttpServerPropertiesManager::ParseAlternativeServiceDict(
@@ skipping 429 matching lines @@
         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) {
-    const HostPortPair& server = map_it->first;
+    // 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());
     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;
     }
   }
 
@@ skipping 173 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net