Update from https://crrev.com/306655

net/http/http_server_properties_impl.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_server_properties_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 109 matching lines @@
   for (SpdyServerHostPortMap::const_iterator it = spdy_servers_map_.begin();
        it != spdy_servers_map_.end() && count < max_size; ++it) {
     const std::string spdy_server_host_port = it->first;
     if (it->second) {
       spdy_server_list->Append(new base::StringValue(spdy_server_host_port));
       ++count;
     }
   }
 }
 
-// static
-std::string HttpServerPropertiesImpl::GetFlattenedSpdyServer(
-    const net::HostPortPair& host_port_pair) {
-  std::string spdy_server;
-  spdy_server.append(host_port_pair.host());
-  spdy_server.append(":");
-  base::StringAppendF(&spdy_server, "%d", host_port_pair.port());
-  return spdy_server;
-}
-
 static const AlternateProtocolInfo* g_forced_alternate_protocol = NULL;
 
 // static
 void HttpServerPropertiesImpl::ForceAlternateProtocol(
     const AlternateProtocolInfo& info) {
   // Note: we're going to leak this.
   if (g_forced_alternate_protocol)
     delete g_forced_alternate_protocol;
   g_forced_alternate_protocol = new AlternateProtocolInfo(info);
 }
@@ skipping 15 matching lines @@
   canonical_host_to_origin_map_.clear();
   spdy_settings_map_.Clear();
   supports_quic_map_.clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsSpdy(
     const net::HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
-  std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
 
   SpdyServerHostPortMap::iterator spdy_host_port =
-      spdy_servers_map_.Get(spdy_server);
+      spdy_servers_map_.Get(host_port_pair.ToString());
   if (spdy_host_port != spdy_servers_map_.end())
     return spdy_host_port->second;
   return false;
 }
 
 void HttpServerPropertiesImpl::SetSupportsSpdy(
     const net::HostPortPair& host_port_pair,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return;
-  std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
 
   SpdyServerHostPortMap::iterator spdy_host_port =
-      spdy_servers_map_.Get(spdy_server);
+      spdy_servers_map_.Get(host_port_pair.ToString());
   if ((spdy_host_port != spdy_servers_map_.end()) &&
       (spdy_host_port->second == support_spdy)) {
     return;
   }
   // Cache the data.
-  spdy_servers_map_.Put(spdy_server, support_spdy);
+  spdy_servers_map_.Put(host_port_pair.ToString(), support_spdy);
 }
 
 bool HttpServerPropertiesImpl::HasAlternateProtocol(
     const HostPortPair& server) {
   if (g_forced_alternate_protocol)
     return true;
   AlternateProtocolMap::const_iterator it = alternate_protocol_map_.Get(server);
-  if (it != alternate_protocol_map_.end() &&
-      it->second.probability >= alternate_protocol_probability_threshold_) {
-    return true;
+  if (it != alternate_protocol_map_.end())
+    return it->second.probability >= alternate_protocol_probability_threshold_;
+
+  auto canonical = GetCanonicalHost(server);
+  if (canonical == canonical_host_to_origin_map_.end() ||
+      canonical->second.Equals(server)) {
+    return false;
   }
 
-  return GetCanonicalHost(server) != canonical_host_to_origin_map_.end();
+  return HasAlternateProtocol(canonical->second);
 }
 
 std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
     const HostPortPair& server) {
   // If this host ends with a canonical suffix, then return the canonical
   // suffix.
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(server.host(), canonical_suffixes_[i], false)) {
       return canonical_suffix;
@@ skipping 274 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net