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 128 matching lines @@
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(const HostPortPair& server,
                                                   bool support_spdy) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
-bool HttpServerPropertiesManager::RequiresHTTP11(
-    const net::HostPortPair& server) {
+bool HttpServerPropertiesManager::RequiresHTTP11(const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->RequiresHTTP11(server);
 }
 
 void HttpServerPropertiesManager::SetHTTP11Required(
-    const net::HostPortPair& server) {
+    const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   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);
 }
 
 bool HttpServerPropertiesManager::HasAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->HasAlternateProtocol(server);
 }
 
-AlternateProtocolInfo HttpServerPropertiesManager::GetAlternateProtocol(
+const 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) {
   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(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->ClearAlternateProtocol(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 224 matching lines @@
       if (port_alternate_protocol_dict->HasKey("probability") &&
           !port_alternate_protocol_dict->GetDoubleWithoutPathExpansion(
               "probability", &probability)) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
       }
 
       AlternateProtocolInfo port_alternate_protocol(static_cast<uint16>(port),
                                                     protocol, probability);
-      alternate_protocol_map->Put(server, port_alternate_protocol);
+      alternate_protocol_map->Put(
+          server, AlternateProtocols(/*size=*/1, port_alternate_protocol));
     }
 
     // Get SupportsQuic.
     DCHECK(supports_quic_map->find(server) == supports_quic_map->end());
     const base::DictionaryValue* supports_quic_dict = NULL;
     if (server_pref_dict->GetDictionaryWithoutPathExpansion(
             "supports_quic", &supports_quic_dict)) {
       bool used_quic = 0;
       if (!supports_quic_dict->GetBooleanWithoutPathExpansion(
               "used_quic", &used_quic)) {
@@ skipping 170 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(supports_quic_map),
           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,
     SupportsQuicMap* supports_quic_map,
     ServerNetworkStatsMap* server_network_stats_map,
@@ skipping 33 matching lines @@
     } else {
       it->second.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)) {
+    const AlternateProtocols& alternate_protocols = map_it->second;
+    AlternateProtocols::const_iterator alternate_protocol;
+    for (alternate_protocol = alternate_protocols.begin();
+         alternate_protocol != alternate_protocols.end();
+         ++alternate_protocol) {
+      if (!IsAlternateProtocolValid(alternate_protocol->protocol)) {
+        break;
+      }
+    }
+    // Do not add AlternateProtocols unless all of them have a valid protocol.
+    if (alternate_protocol != alternate_protocols.end()) {
       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_protocol = &map_it->second;
+      it->second.alternate_protocols = &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;
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
@@ skipping 41 matching lines @@
            it != server_pref.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("settings", spdy_settings_dict);
     }
 
     // Save alternate_protocol.
-    const AlternateProtocolInfo* port_alternate_protocol =
-        server_pref.alternate_protocol;
-    if (port_alternate_protocol && !port_alternate_protocol->is_broken) {
+    if (server_pref.alternate_protocols &&
+        server_pref.alternate_protocols->size() >= 1) {
       base::DictionaryValue* port_alternate_protocol_dict =
           new base::DictionaryValue;
+      const AlternateProtocolInfo& port_alternate_protocol =
+          server_pref.alternate_protocols->at(0);
       port_alternate_protocol_dict->SetInteger("port",
-                                               port_alternate_protocol->port);
+                                               port_alternate_protocol.port);
       const char* protocol_str =
-          AlternateProtocolToString(port_alternate_protocol->protocol);
+          AlternateProtocolToString(port_alternate_protocol.protocol);
       port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
       port_alternate_protocol_dict->SetDouble(
-          "probability", port_alternate_protocol->probability);
+          "probability", port_alternate_protocol.probability);
       server_pref_dict->SetWithoutPathExpansion(
           "alternate_protocol", port_alternate_protocol_dict);
     }
 
     // Save supports_quic.
     if (server_pref.supports_quic) {
       base::DictionaryValue* supports_quic_dict = new base::DictionaryValue;
       const SupportsQuic* supports_quic = server_pref.supports_quic;
       supports_quic_dict->SetBoolean("used_quic", supports_quic->used_quic);
       supports_quic_dict->SetString("address", supports_quic->address);
@@ skipping 34 matching lines @@
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net