Change the AlternativeServiceMap with SchemeOriginPair 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 128 matching lines @@
 }
 
 void HttpServerPropertiesManager::Clear(const base::Closure& completion) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   http_server_properties_impl_->Clear();
   UpdatePrefsFromCacheOnNetworkThread(completion);
 }
 
 bool HttpServerPropertiesManager::SupportsRequestPriority(
-    const HostPortPair& server) {
+    const SchemeOriginPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->SupportsRequestPriority(server);
 }
 
 bool HttpServerPropertiesManager::GetSupportsSpdy(const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetSupportsSpdy(server);
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(const HostPortPair& server,
@@ skipping 20 matching lines @@
   ScheduleUpdatePrefsOnNetworkThread(HTTP_11_REQUIRED);
 }
 
 void HttpServerPropertiesManager::MaybeForceHTTP11(const HostPortPair& server,
                                                    SSLConfig* ssl_config) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
 AlternativeServiceVector HttpServerPropertiesManager::GetAlternativeServices(
-    const HostPortPair& origin) {
+    const SchemeOriginPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetAlternativeServices(origin);
 }
 
 bool HttpServerPropertiesManager::SetAlternativeService(
-    const HostPortPair& origin,
+    const SchemeOriginPair& origin,
     const AlternativeService& alternative_service,
     double alternative_probability,
     base::Time expiration) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   const bool changed = http_server_properties_impl_->SetAlternativeService(
       origin, alternative_service, alternative_probability, expiration);
   if (changed) {
     ScheduleUpdatePrefsOnNetworkThread(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
 
 bool HttpServerPropertiesManager::SetAlternativeServices(
-    const HostPortPair& origin,
+    const SchemeOriginPair& origin,
     const AlternativeServiceInfoVector& alternative_service_info_vector) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   const bool changed = http_server_properties_impl_->SetAlternativeServices(
       origin, alternative_service_info_vector);
   if (changed) {
     ScheduleUpdatePrefsOnNetworkThread(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
 
@@ skipping 35 matching lines @@
   http_server_properties_impl_->ConfirmAlternativeService(alternative_service);
   bool new_value = http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
   // For persisting, we only care about the value returned by
   // IsAlternativeServiceBroken. If that value changes, then call persist.
   if (old_value != new_value)
     ScheduleUpdatePrefsOnNetworkThread(CONFIRM_ALTERNATIVE_SERVICE);
 }
 
 void HttpServerPropertiesManager::ClearAlternativeServices(
-    const HostPortPair& origin) {
+    const SchemeOriginPair& origin) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   const AlternativeServiceMap& map =
       http_server_properties_impl_->alternative_service_map();
   size_t old_size = map.size();
   http_server_properties_impl_->ClearAlternativeServices(origin);
   size_t new_size = map.size();
   // Persist only if we have deleted an entry.
   if (old_size != new_size)
     ScheduleUpdatePrefsOnNetworkThread(CLEAR_ALTERNATIVE_SERVICE);
 }
@@ skipping 275 matching lines @@
     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);
+    // TODO(zhongyi): figure out which scheme is using.
+    SchemeOriginPair scheme_origin_pair("https", server);

[Zhongyi Shi, 2016/03/22 20:49:08]

I'm not sure, whether setting the scheme to be "https" is safe here. Or do we
need the info from callers? 

[Ryan Hamilton, 2016/03/24 22:23:14]

I recommend chatting with Raman about this. He's the expert at the serialization
layer and has done this kind of change before.

[Zhongyi Shi, 2016/04/04 18:58:36]

After chatting with Raman and a deep digging in the code, found a lot more
changes to persist disk data. We need to change all the keys from HostPortPair
to SchemeHostPort, now seperate code to new dependent CL.

     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) {
       spdy_servers->push_back(server_str);
     }
 
     AddToSpdySettingsMap(server, *server_pref_dict, spdy_settings_map);
-    if (!AddToAlternativeServiceMap(server, *server_pref_dict,
+    if (!AddToAlternativeServiceMap(scheme_origin_pair, *server_pref_dict,
                                     alternative_service_map) ||
         !AddToNetworkStatsMap(server, *server_pref_dict, network_stats_map)) {
       return false;
     }
   }
   return true;
 }
 
 void HttpServerPropertiesManager::AddToSpdySettingsMap(
     const HostPortPair& server,
@@ skipping 101 matching lines @@
         base::Time::FromInternalValue(expiration_int64);
     return true;
   }
 
   DVLOG(1) << "Malformed alternative service expiration for server: "
            << server_str;
   return false;
 }
 
 bool HttpServerPropertiesManager::AddToAlternativeServiceMap(
-    const HostPortPair& server,
+    const SchemeOriginPair& server,
     const base::DictionaryValue& server_pref_dict,
     AlternativeServiceMap* alternative_service_map) {
   DCHECK(alternative_service_map->Peek(server) ==
          alternative_service_map->end());
   const base::ListValue* alternative_service_list;
   if (!server_pref_dict.GetListWithoutPathExpansion(
           kAlternativeServiceKey, &alternative_service_list)) {
     return true;
   }
 
   AlternativeServiceInfoVector alternative_service_info_vector;
   for (const base::Value* alternative_service_list_item :
        *alternative_service_list) {
     const base::DictionaryValue* alternative_service_dict;
     if (!alternative_service_list_item->GetAsDictionary(
             &alternative_service_dict))
       return false;
     AlternativeServiceInfo alternative_service_info;
     if (!ParseAlternativeServiceDict(*alternative_service_dict,
-                                     server.ToString(),
+                                     server.host_port_pair().ToString(),
                                      &alternative_service_info)) {
       return false;
     }
     if (base::Time::Now() < alternative_service_info.expiration) {
       alternative_service_info_vector.push_back(alternative_service_info);
     }
   }
 
   if (alternative_service_info_vector.empty()) {
     return false;
@@ skipping 196 matching lines @@
   const AlternativeServiceMap& map =
       http_server_properties_impl_->alternative_service_map();
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers.Memory",
                        map.size());
   count = 0;
   typedef std::map<std::string, bool> CanonicalHostPersistedMap;
   CanonicalHostPersistedMap persisted_map;
   // Maintain MRU order.
   for (AlternativeServiceMap::const_reverse_iterator it = map.rbegin();
        it != map.rend() && count < kMaxAlternateProtocolHostsToPersist; ++it) {
-    const HostPortPair& server = it->first;
+    const SchemeOriginPair& server = it->first;
     AlternativeServiceInfoVector notbroken_alternative_service_info_vector;
     for (const AlternativeServiceInfo& alternative_service_info : it->second) {
       // Do not persist expired entries.
       if (alternative_service_info.expiration < base::Time::Now()) {
         continue;
       }
       AlternativeService alternative_service(
           alternative_service_info.alternative_service);
       if (!IsAlternateProtocolValid(alternative_service.protocol)) {
         continue;
@@ skipping 129 matching lines @@
       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) {
-    const HostPortPair& server = map_it->first;
+    const HostPortPair& server = map_it->first.host_port_pair();
     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;
     }
   }
 
@@ skipping 159 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net