Update from https://crrev.com/314320

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 150 matching lines @@
 void HttpServerPropertiesImpl::Clear() {
   DCHECK(CalledOnValidThread());
   spdy_servers_map_.Clear();
   alternate_protocol_map_.Clear();
   canonical_host_to_origin_map_.clear();
   spdy_settings_map_.Clear();
   supports_quic_map_.clear();
   server_network_stats_map_.Clear();
 }
 
-bool HttpServerPropertiesImpl::SupportsSpdy(
+bool HttpServerPropertiesImpl::SupportsRequestPriority(
     const HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
 
   SpdyServerHostPortMap::iterator spdy_host_port =
       spdy_servers_map_.Get(host_port_pair.ToString());
-  if (spdy_host_port != spdy_servers_map_.end())
-    return spdy_host_port->second;
-  return false;
+  if (spdy_host_port != spdy_servers_map_.end() && spdy_host_port->second)
+    return true;
+
+  if (!HasAlternateProtocol(host_port_pair))
+    return false;
+
+  AlternateProtocolInfo info = GetAlternateProtocol(host_port_pair);
+  return info.protocol == QUIC;
 }
 
 void HttpServerPropertiesImpl::SetSupportsSpdy(
     const HostPortPair& host_port_pair,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return;
 
   SpdyServerHostPortMap::iterator spdy_host_port =
@@ skipping 35 matching lines @@
     const HostPortPair& server) {
   if (g_forced_alternate_protocol)
     return true;
   AlternateProtocolMap::const_iterator it =
       GetAlternateProtocolIterator(server);
   return it != alternate_protocol_map_.end() &&
          it->second.probability >= alternate_protocol_probability_threshold_;
 }
 
 std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
-    const HostPortPair& server) {
+    const std::string& host) {
   // 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)) {
+    if (EndsWith(host, canonical_suffixes_[i], false)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
 AlternateProtocolInfo
 HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(HasAlternateProtocol(server));
@@ skipping 81 matching lines @@
   BrokenAlternateProtocolEntry entry;
   entry.server = server;
   entry.when = base::TimeTicks::Now() + delay * (1 << (count - 1));
   broken_alternate_protocol_list_.push_back(entry);
 
   // Do not leave this host as canonical so that we don't infer the other
   // hosts are also broken without testing them first.
   RemoveCanonicalHost(server);
 
   // If this is the only entry in the list, schedule an expiration task.
-  // Otherwse it will be rescheduled automatically when the pending
-  // task runs.
+  // Otherwise it will be rescheduled automatically when the pending task runs.
   if (broken_alternate_protocol_list_.size() == 1) {
     ScheduleBrokenAlternateProtocolMappingsExpiration();
   }
 }
 
 bool HttpServerPropertiesImpl::WasAlternateProtocolRecentlyBroken(
     const HostPortPair& server) {
   return ContainsKey(broken_alternate_protocol_map_, server);
 }
 
@@ skipping 175 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