ABANDONED Handle multiple AlternateProtocols for each HostPortPair.

net/http/http_stream_factory.cc

 // Copyright (c) 2012 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_stream_factory.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 72 matching lines @@
   }
 
   if (protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return;
 
   HostPortPair host_port(http_host_port_pair);
   const HostMappingRules* mapping_rules = GetHostMappingRules();
   if (mapping_rules)
     mapping_rules->RewriteHost(&host_port);
 
-  if (http_server_properties->HasAlternateProtocol(host_port)) {
-    const AlternateProtocolInfo existing_alternate =
-        http_server_properties->GetAlternateProtocol(host_port);
-    // If we think the alternate protocol is broken, don't change it.
-    if (existing_alternate.protocol == ALTERNATE_PROTOCOL_BROKEN)
-      return;
-  }
-
-  http_server_properties->SetAlternateProtocol(host_port, port, protocol,
-                                               probability);
+  http_server_properties->AddAlternateProtocol(
+      host_port, port, protocol, probability);

[Ryan Hamilton, 2014/11/03 19:00:30]

Does this need to Clear() first? Otherwise it seems like it will simply append?

[Bence, 2014/11/03 22:32:26]

Previous behavior is that if an alternate protocol was known to be broken, we
don't overwrite it.  This can be conveniently mimiced this way.

BTW Alternate protocol and alternate service headers are going to be cumulative,
are they not?

[Ryan Hamilton, 2014/11/04 18:56:22]

In the case of non-broken, the old code overwrite the existing entry with the
new entry. With this new code, it seems like we will end up appending, right? I
don't think that's desirable.
In the sense that we should union them together? Possibly. Although I was
talking with alyssa and perhaps it makes more sense to use Alt-Svc exclusively
if it exists. And only use Alternate-Protocol if Alt-Svc does not exist.

[Bence, 2014/11/04 21:55:50]

Done.  FYI I had to create a new method in HttpServerProperties*, because
GetAlternateProtocol fails if there is none, and HasAlternateProtocol returns
false if they are all below the probability threshold.

 }
 
 GURL HttpStreamFactory::ApplyHostMappingRules(const GURL& url,
                                               HostPortPair* endpoint) {
   const HostMappingRules* mapping_rules = GetHostMappingRules();
   if (mapping_rules && mapping_rules->RewriteHost(endpoint)) {
     url::Replacements<char> replacements;
     const std::string port_str = base::IntToString(endpoint->port());
     replacements.SetPort(port_str.c_str(), url::Component(0, port_str.size()));
     replacements.SetHost(endpoint->host().c_str(),
                          url::Component(0, endpoint->host().size()));
     return url.ReplaceComponents(replacements);
   }
   return url;
 }
 
 HttpStreamFactory::HttpStreamFactory() {}
 
 }  // namespace net