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 185 matching lines @@
                    << server_str;
           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);
     }
 
-    // Get alternate_protocol server.
+    // Get alternative_services...
     DCHECK(alternate_protocol_map->Peek(server) ==
            alternate_protocol_map->end());
-    const base::DictionaryValue* port_alternate_protocol_dict = NULL;
-    if (server_pref_dict->GetDictionaryWithoutPathExpansion(
-            "alternate_protocol", &port_alternate_protocol_dict)) {
-      int port = 0;
-      if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
-              "port", &port) ||
-          !IsPortValid(port)) {
-        DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
-        detected_corrupted_prefs = true;
-        continue;
+    const base::ListValue* alternate_protocol_list = NULL;
+    if (server_pref_dict->GetListWithoutPathExpansion(
+            "alternative_services", &alternate_protocol_list) &&
+        !alternate_protocol_list->empty()) {
+      AlternateProtocols alternate_protocols;
+      for (const auto& alternate_protocol_list_item :
+           *alternate_protocol_list) {
+        base::DictionaryValue* alternate_protocol_dict;
+        if (!alternate_protocol_list_item->GetAsDictionary(
+                &alternate_protocol_dict))
+          continue;
+        AlternateProtocolInfo alternate_protocol;
+
+        int port = 0;
+        if (!alternate_protocol_dict->GetInteger("port", &port) ||
+            !IsPortValid(port)) {
+          DVLOG(1) << "Malformed AltSvc port for server: " << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+        alternate_protocol.port = static_cast<uint16>(port);
+
+        std::string protocol_str;
+        if (!alternate_protocol_dict->GetStringWithoutPathExpansion(
+                "protocol_str", &protocol_str)) {
+          DVLOG(1) << "Malformed AltSvc protocol string for server: "
+                   << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+        AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
+        if (!IsAlternateProtocolValid(protocol)) {
+          DVLOG(1) << "Invalid AltSvc protocol string for server: "
+                   << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+        alternate_protocol.protocol = AlternateProtocolFromString(protocol_str);
+
+        double probability = 1;
+        if (alternate_protocol_dict->HasKey("probability") &&
+            !alternate_protocol_dict->GetDoubleWithoutPathExpansion(
+                "probability", &probability)) {
+          DVLOG(1) << "Malformed AltSvc probability for server: " << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+        alternate_protocol.probability = probability;
+
+        alternate_protocols.push_back(alternate_protocol);
       }
-      std::string protocol_str;
-      if (!port_alternate_protocol_dict->GetStringWithoutPathExpansion(
-              "protocol_str", &protocol_str)) {
-        DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
-        detected_corrupted_prefs = true;
-        continue;
+      alternate_protocol_map->Put(server, alternate_protocols);
+    } else {
+      // ...or alternate_protocol.

[Bence, 2015/01/30 21:24:50]

Do we need to be able to load old settings, or can we just forget about them?

[Ryan Hamilton, 2015/01/30 21:50:19]

We definitely want to support old settings. It looks like this block is pretty
similar to the inner block above. Consider factoring out a helper method to call
in both codepaths.

[Bence, 2015/02/06 19:59:40]

Done.

+      const base::DictionaryValue* port_alternate_protocol_dict = NULL;
+      if (server_pref_dict->GetDictionaryWithoutPathExpansion(
+              "alternate_protocol", &port_alternate_protocol_dict)) {
+        int port = 0;
+        if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
+                "port", &port) ||
+            !IsPortValid(port)) {
+          DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+        std::string protocol_str;
+        if (!port_alternate_protocol_dict->GetStringWithoutPathExpansion(
+                "protocol_str", &protocol_str)) {
+          DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+        AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
+        if (!IsAlternateProtocolValid(protocol)) {
+          DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
+          detected_corrupted_prefs = true;
+          continue;
+        }
+
+        double probability = 1;
+        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, AlternateProtocols(/*size=*/1, port_alternate_protocol));
       }
-      AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
-      if (!IsAlternateProtocolValid(protocol)) {
-        DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
-        detected_corrupted_prefs = true;
-        continue;
-      }
-
-      double probability = 1;
-      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);
     }
 
     // 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)) {
-      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 40 matching lines @@
       for (SettingsMap::const_iterator it = server_pref.settings_map->begin();
            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) {
-      base::DictionaryValue* port_alternate_protocol_dict =
-          new base::DictionaryValue;
-      port_alternate_protocol_dict->SetInteger("port",
-                                               port_alternate_protocol->port);
-      const char* protocol_str =
-          AlternateProtocolToString(port_alternate_protocol->protocol);
-      port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
-      port_alternate_protocol_dict->SetDouble(
-          "probability", port_alternate_protocol->probability);
-      server_pref_dict->SetWithoutPathExpansion(
-          "alternate_protocol", port_alternate_protocol_dict);
+    // Save alternative_services.
+    if (server_pref.alternate_protocols &&
+        server_pref.alternate_protocols->size() > 0) {
+      base::ListValue* alternate_protocols_list = new base::ListValue;
+      for (AlternateProtocols::const_iterator alternate_protocol =
+               server_pref.alternate_protocols->begin();
+           alternate_protocol != server_pref.alternate_protocols->end();
+           ++alternate_protocol) {
+        base::DictionaryValue* alternate_protocol_dict =
+            new base::DictionaryValue;
+        alternate_protocol_dict->SetInteger("port", alternate_protocol->port);
+        alternate_protocol_dict->SetString("host", server.host());
+        alternate_protocol_dict->SetString(
+            "protocol_str",
+            AlternateProtocolToString(alternate_protocol->protocol));
+        alternate_protocol_dict->SetDouble("probability",
+                                           alternate_protocol->probability);
+        alternate_protocols_list->Append(alternate_protocol_dict);
+      }
+      server_pref_dict->SetWithoutPathExpansion("alternative_services",
+                                                alternate_protocols_list);
     }
 
     // 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);
       server_pref_dict->SetWithoutPathExpansion(
           "supports_quic", supports_quic_dict);
@@ skipping 32 matching lines @@
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net