Alt-Svc 8: Change Supports SPDY list using SHP as the key.

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 132 matching lines @@
   http_server_properties_impl_->Clear();
   UpdatePrefsFromCacheOnNetworkThread(completion);
 }
 
 bool HttpServerPropertiesManager::SupportsRequestPriority(
     const url::SchemeHostPort& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->SupportsRequestPriority(server);
 }
 
-bool HttpServerPropertiesManager::GetSupportsSpdy(const HostPortPair& server) {
+bool HttpServerPropertiesManager::GetSupportsSpdy(
+    const url::SchemeHostPort& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetSupportsSpdy(server);
 }
 
-void HttpServerPropertiesManager::SetSupportsSpdy(const HostPortPair& server,
-                                                  bool support_spdy) {
+void HttpServerPropertiesManager::SetSupportsSpdy(
+    const url::SchemeHostPort& server,
+    bool support_spdy) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   bool old_support_spdy = http_server_properties_impl_->GetSupportsSpdy(server);
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   bool new_support_spdy = http_server_properties_impl_->GetSupportsSpdy(server);
   if (old_support_spdy != new_support_spdy)
     ScheduleUpdatePrefsOnNetworkThread(SUPPORTS_SPDY);
 }
 
 bool HttpServerPropertiesManager::RequiresHTTP11(const HostPortPair& server) {
@@ skipping 110 matching lines @@
 }
 
 scoped_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& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetSpdySettings(host_port_pair);
+  return http_server_properties_impl_->GetSpdySettings(origin);
 }
 
 bool HttpServerPropertiesManager::SetSpdySetting(
-    const HostPortPair& host_port_pair,
+    const url::SchemeHostPort& origin,
     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(origin, id, flags, value);
   if (persist)
     ScheduleUpdatePrefsOnNetworkThread(SET_SPDY_SETTING);
   return persist;
 }
 
 void HttpServerPropertiesManager::ClearSpdySettings(
-    const HostPortPair& host_port_pair) {
+    const url::SchemeHostPort& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->ClearSpdySettings(host_port_pair);
+  http_server_properties_impl_->ClearSpdySettings(origin);
   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 14 matching lines @@
   IPAddress old_last_quic_addr;
   http_server_properties_impl_->GetSupportsQuic(&old_last_quic_addr);
   http_server_properties_impl_->SetSupportsQuic(used_quic, address);
   IPAddress new_last_quic_addr;
   http_server_properties_impl_->GetSupportsQuic(&new_last_quic_addr);
   if (old_last_quic_addr != new_last_quic_addr)
     ScheduleUpdatePrefsOnNetworkThread(SET_SUPPORTS_QUIC);
 }
 
 void HttpServerPropertiesManager::SetServerNetworkStats(
-    const HostPortPair& host_port_pair,
+    const url::SchemeHostPort& origin,
     ServerNetworkStats stats) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   ServerNetworkStats old_stats;
   const ServerNetworkStats* old_stats_ptr =
-      http_server_properties_impl_->GetServerNetworkStats(host_port_pair);
-  if (http_server_properties_impl_->GetServerNetworkStats(host_port_pair))
+      http_server_properties_impl_->GetServerNetworkStats(origin);
+  if (http_server_properties_impl_->GetServerNetworkStats(origin))
     old_stats = *old_stats_ptr;
-  http_server_properties_impl_->SetServerNetworkStats(host_port_pair, stats);
+  http_server_properties_impl_->SetServerNetworkStats(origin, stats);
   ServerNetworkStats new_stats =
-      *(http_server_properties_impl_->GetServerNetworkStats(host_port_pair));
+      *(http_server_properties_impl_->GetServerNetworkStats(origin));
   if (old_stats != new_stats)
     ScheduleUpdatePrefsOnNetworkThread(SET_SERVER_NETWORK_STATS);
 }
 
 const ServerNetworkStats* HttpServerPropertiesManager::GetServerNetworkStats(
-    const HostPortPair& host_port_pair) {
+    const url::SchemeHostPort& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetServerNetworkStats(host_port_pair);
+  return http_server_properties_impl_->GetServerNetworkStats(origin);
 }
 
 const ServerNetworkStatsMap&
 HttpServerPropertiesManager::server_network_stats_map() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->server_network_stats_map();
 }
 
 bool HttpServerPropertiesManager::SetQuicServerInfo(
     const QuicServerId& server_id,
@@ skipping 188 matching lines @@
       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);
-
     // TODO(zhongyi): persist server's scheme/host/pair in a new version.
     // Never call AddToAlternativeServiceMap for old versions disk data.
     url::SchemeHostPort scheme_origin_pair("https", server.host(),
                                            server.port());
+
+    AddToSpdySettingsMap(scheme_origin_pair, *server_pref_dict,
+                         spdy_settings_map);
+
     if (version <= 4) {
       DVLOG(1) << "Old version, won't update Alt-Svc from disck data";
     }
     if (!AddToAlternativeServiceMap(scheme_origin_pair, *server_pref_dict,
                                     alternative_service_map) ||
-        !AddToNetworkStatsMap(server, *server_pref_dict, network_stats_map)) {
+        !AddToNetworkStatsMap(scheme_origin_pair, *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;
@@ skipping 147 matching lines @@
   if (!supports_quic_dict->GetStringWithoutPathExpansion(kAddressKey,
                                                          &address) ||
       !last_quic_address->AssignFromIPLiteral(address)) {
     DVLOG(1) << "Malformed SupportsQuic";
     return false;
   }
   return true;
 }
 
 bool HttpServerPropertiesManager::AddToNetworkStatsMap(
-    const HostPortPair& server,
+    const url::SchemeHostPort& 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 = nullptr;
   if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
           kNetworkStatsKey, &server_network_stats_dict)) {
     return true;
   }
   int srtt;
   if (!server_network_stats_dict->GetIntegerWithoutPathExpansion(kSrttKey,
@@ skipping 271 matching lines @@
     const base::Closure& completion) {
   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 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);
+      url::SchemeHostPort scheme_origin_pair =
+          url::SchemeHostPort::FromString(s);
+      HostPortPair server =
+          HostPortPair::FromSchemeHostPort(scheme_origin_pair);
       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) {
-    const HostPortPair& server = map_it->first;
+    const HostPortPair& server =
+        HostPortPair::FromSchemeHostPort(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;
     }
   }
 
@@ skipping 10 matching lines @@
       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) {
-    const HostPortPair& server = map_it->first;
+    const HostPortPair& server =
+        HostPortPair::FromSchemeHostPort(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;
     }
   }
 
@@ skipping 142 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net