ABANDONED Handle multiple AlternateProtocols for each HostPortPair.

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 40 matching lines @@
 const int kMaxServerNetworkStatsHostsToPersist = 200;
 
 const char kVersionKey[] = "version";
 const char kServersKey[] = "servers";
 const char kSupportsSpdyKey[] = "supports_spdy";
 const char kSettingsKey[] = "settings";
 const char kSupportsQuicKey[] = "supports_quic";
 const char kUsedQuicKey[] = "used_quic";
 const char kAddressKey[] = "address";
 const char kAlternateProtocolKey[] = "alternate_protocol";
+const char kAlternativeServicesKey[] = "alternative_services";
 const char kPortKey[] = "port";
+const char kHostKey[] = "host";
 const char kProtocolKey[] = "protocol_str";
 const char kProbabilityKey[] = "probability";
 const char kNetworkStatsKey[] = "network_stats";
 const char kSrttKey[] = "srtt";
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
@@ skipping 101 matching lines @@
   http_server_properties_impl_->SetHTTP11Required(server);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::MaybeForceHTTP11(const HostPortPair& server,
                                                    SSLConfig* ssl_config) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
-AlternateProtocolInfo HttpServerPropertiesManager::GetAlternateProtocol(
+AlternateProtocols HttpServerPropertiesManager::GetAlternateProtocols(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  return http_server_properties_impl_->GetAlternateProtocol(server);
+  return http_server_properties_impl_->GetAlternateProtocols(server);
 }
 
-void HttpServerPropertiesManager::SetAlternateProtocol(
+void HttpServerPropertiesManager::AddAlternateProtocol(
     const HostPortPair& server,
     uint16 alternate_port,
     AlternateProtocol alternate_protocol,
     double alternate_probability) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->SetAlternateProtocol(
+  http_server_properties_impl_->AddAlternateProtocol(
       server, alternate_port, alternate_protocol, alternate_probability);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::SetBrokenAlternateProtocol(
-    const HostPortPair& server) {
+    const HostPortPair& server,
+    const AlternateProtocolInfo& broken_alternate_protocol) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->SetBrokenAlternateProtocol(server);
+  http_server_properties_impl_->SetBrokenAlternateProtocol(
+      server, broken_alternate_protocol);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 bool HttpServerPropertiesManager::WasAlternateProtocolRecentlyBroken(
-    const HostPortPair& server) {
+    const HostPortPair& server,
+    const AlternateProtocolInfo& alternate_protocol) const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->WasAlternateProtocolRecentlyBroken(
-      server);
+      server, alternate_protocol);
 }
 
 void HttpServerPropertiesManager::ConfirmAlternateProtocol(
-    const HostPortPair& server) {
+    const HostPortPair& server,
+    const AlternateProtocolInfo& alternate_protocol) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->ConfirmAlternateProtocol(server);
+  http_server_properties_impl_->ConfirmAlternateProtocol(server,
+                                                         alternate_protocol);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
-void HttpServerPropertiesManager::ClearAlternateProtocol(
+void HttpServerPropertiesManager::ClearAlternateProtocols(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
-  http_server_properties_impl_->ClearAlternateProtocol(server);
+  http_server_properties_impl_->ClearAlternateProtocols(server);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
+void HttpServerPropertiesManager::ClearNonBrokenAlternateProtocols(
+    const HostPortPair& server) {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  http_server_properties_impl_->ClearNonBrokenAlternateProtocols(server);
+  ScheduleUpdatePrefsOnNetworkThread();
+}
+
+void HttpServerPropertiesManager::RemoveAlternateProtocol(
+    const HostPortPair& server,
+    const AlternateProtocolInfo& alternate_protocol) {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  http_server_properties_impl_->RemoveAlternateProtocol(server,
+                                                        alternate_protocol);
+  ScheduleUpdatePrefsOnNetworkThread();
+}
+
 const AlternateProtocolMap&
 HttpServerPropertiesManager::alternate_protocol_map() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->alternate_protocol_map();
 }
 
 void HttpServerPropertiesManager::SetAlternateProtocolProbabilityThreshold(
     double threshold) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetAlternateProtocolProbabilityThreshold(
@@ skipping 246 matching lines @@
   }
   alternate_protocol.protocol = protocol;
 
   return alternate_protocol;
 }
 
 bool HttpServerPropertiesManager::AddToAlternateProtocolMap(
     const HostPortPair& server,
     const base::DictionaryValue& server_pref_dict,
     AlternateProtocolMap* alternate_protocol_map) {
-  // Get alternate_protocol server.
   DCHECK(alternate_protocol_map->Peek(server) == alternate_protocol_map->end());
-  const base::DictionaryValue* alternate_protocol_dict = NULL;
+  // Get alternative_services...
+  const base::ListValue* alternate_protocol_list = NULL;
+  if (server_pref_dict.GetListWithoutPathExpansion(kAlternativeServicesKey,
+                                                   &alternate_protocol_list) &&
+      !alternate_protocol_list->empty()) {
+    AlternateProtocols alternate_protocols;
+    for (base::Value* const alternate_protocol_list_item :
+         *alternate_protocol_list) {
+      base::DictionaryValue* alternate_protocol_dict;
+      if (!alternate_protocol_list_item->GetAsDictionary(
+              &alternate_protocol_dict))
+        return false;
+      AlternateProtocolInfo alternate_protocol = ParseAlternateProtocolDict(
+          *alternate_protocol_dict, server.ToString());
+      if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
+        return false;
+      }
+      alternate_protocols.push_back(alternate_protocol);
+    }
+    alternate_protocol_map->Put(server, alternate_protocols);
+    return true;
+  }
+
+  // ...or alternate_protocol.
+  // TODO(bnc):  Remove this in M45.  (Saving to kAlternativeServicesKey is
+  // targeted to M43, and we do not need preference migration for long.)
+  const base::DictionaryValue* alternate_protocol_dict;
   if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
           kAlternateProtocolKey, &alternate_protocol_dict)) {
     return true;
   }
   AlternateProtocolInfo alternate_protocol =
       ParseAlternateProtocolDict(*alternate_protocol_dict, server.ToString());
-  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
     return false;
-  alternate_protocol_map->Put(server, alternate_protocol);
+  }
+  alternate_protocol_map->Put(
+      server, AlternateProtocols(/*size=*/1, alternate_protocol));
   return true;
 }
 
 bool HttpServerPropertiesManager::ReadSupportsQuic(
     const base::DictionaryValue& http_server_properties_dict,
     IPAddressNumber* last_quic_address) {
   const base::DictionaryValue* supports_quic_dict = NULL;
   if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
           kSupportsQuicKey, &supports_quic_dict)) {
     return true;
@@ skipping 161 matching lines @@
   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(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
+// AlternateProtocols and SupportsQuic preferences for a server. This is used
 // only in UpdatePrefsOnPrefThread.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
         settings_map(NULL),
-        alternate_protocol(NULL),
+        alternate_protocols(NULL),
         supports_quic(NULL),
         server_network_stats(NULL) {}
   ServerPref(bool supports_spdy,
              const SettingsMap* settings_map,
-             const AlternateProtocolInfo* alternate_protocol,
+             const AlternateProtocols* alternate_protocols,
              const SupportsQuic* supports_quic,
              const ServerNetworkStats* server_network_stats)
       : supports_spdy(supports_spdy),
         settings_map(settings_map),
-        alternate_protocol(alternate_protocol),
+        alternate_protocols(alternate_protocols),
         supports_quic(supports_quic),
         server_network_stats(server_network_stats) {}
   bool supports_spdy;
   const SettingsMap* settings_map;
-  const AlternateProtocolInfo* alternate_protocol;
+  const AlternateProtocols* alternate_protocols;
   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,
     IPAddressNumber* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
@@ skipping 19 matching lines @@
        map_it != spdy_settings_map->end(); ++map_it) {
     const HostPortPair& server = map_it->first;
     server_pref_map[server].settings_map = &map_it->second;
   }
 
   // Add AlternateProtocol servers to server_pref_map.
   for (AlternateProtocolMap::const_iterator map_it =
            alternate_protocol_map->begin();
        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;
+    ServerPrefMap::iterator it = server_pref_map.find(server);
+    if (it == server_pref_map.end()) {
+      ServerPref server_pref(false, NULL, &map_it->second, NULL, NULL);
+      server_pref_map[server] = server_pref;
+    } else {
+      it->second.alternate_protocols = &map_it->second;
     }
-    server_pref_map[server].alternate_protocol = &map_it->second;
   }
 
   // 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);
+    SaveAlternateProtocolToServerPrefs(server_pref.alternate_protocols,
+                                       server_pref_dict, server);
     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);
 
@@ skipping 22 matching lines @@
        it != settings_map->end(); ++it) {
     SpdySettingsIds id = it->first;
     uint32 value = it->second.second;
     std::string key = base::StringPrintf("%u", id);
     spdy_settings_dict->SetInteger(key, value);
   }
   server_pref_dict->SetWithoutPathExpansion(kSettingsKey, spdy_settings_dict);
 }
 
 void HttpServerPropertiesManager::SaveAlternateProtocolToServerPrefs(
-    const AlternateProtocolInfo* port_alternate_protocol,
-    base::DictionaryValue* server_pref_dict) {
-  if (!port_alternate_protocol || port_alternate_protocol->is_broken)
+    const AlternateProtocols* alternate_protocols,
+    base::DictionaryValue* server_pref_dict,
+    const HostPortPair& server) {
+  if (!alternate_protocols || alternate_protocols->size() == 0)
     return;
-
-  base::DictionaryValue* port_alternate_protocol_dict =
-      new base::DictionaryValue;
-  port_alternate_protocol_dict->SetInteger(kPortKey,
-                                           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);
+  base::ListValue* alternate_protocols_list = new base::ListValue;
+  for (const AlternateProtocolInfo& alternate_protocol : *alternate_protocols) {
+    if (alternate_protocol.is_broken)
+      continue;
+    DCHECK(IsAlternateProtocolValid(alternate_protocol.protocol));
+    base::DictionaryValue* alternate_protocol_dict = new base::DictionaryValue;
+    alternate_protocol_dict->SetInteger(kPortKey, alternate_protocol.port);
+    alternate_protocol_dict->SetString(kHostKey, server.host());
+    alternate_protocol_dict->SetString(
+        kProtocolKey, AlternateProtocolToString(alternate_protocol.protocol));
+    alternate_protocol_dict->SetDouble(kProbabilityKey,
+                                       alternate_protocol.probability);
+    alternate_protocols_list->Append(alternate_protocol_dict);
+  }
+  if (alternate_protocols_list->GetSize() == 0)
+    return;
+  server_pref_dict->SetWithoutPathExpansion(kAlternativeServicesKey,
+                                            alternate_protocols_list);
 }
 
 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, true);
@@ skipping 19 matching lines @@
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net