Update from https://crrev.com/315085

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 84 matching lines @@
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
   for (SpdySettingsMap::reverse_iterator it = spdy_settings_map->rbegin();
        it != spdy_settings_map->rend(); ++it) {
     spdy_settings_map_.Put(it->first, it->second);
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSupportsQuic(
-    SupportsQuicMap* supports_quic_map) {
-  for (SupportsQuicMap::reverse_iterator it = supports_quic_map->rbegin();
-       it != supports_quic_map->rend();
-       ++it) {
-    supports_quic_map_.insert(std::make_pair(it->first, it->second));
-  }
+    IPAddressNumber* last_address) {
+  if (last_address)
+    last_quic_address_ = *last_address;
 }
 
 void HttpServerPropertiesImpl::InitializeServerNetworkStats(
     ServerNetworkStatsMap* server_network_stats_map) {
   for (ServerNetworkStatsMap::reverse_iterator it =
            server_network_stats_map->rbegin();
        it != server_network_stats_map->rend(); ++it) {
     server_network_stats_map_.Put(it->first, it->second);
   }
 }
@@ skipping 36 matching lines @@
 base::WeakPtr<HttpServerProperties> HttpServerPropertiesImpl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 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();
+  last_quic_address_.clear();
   server_network_stats_map_.Clear();
 }
 
 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() && spdy_host_port->second)
     return true;
 
-  if (!HasAlternateProtocol(host_port_pair))
-    return false;
-
-  AlternateProtocolInfo info = GetAlternateProtocol(host_port_pair);
+  const 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;
 
@@ skipping 25 matching lines @@
   http11_servers_.insert(host_port_pair);
 }
 
 void HttpServerPropertiesImpl::MaybeForceHTTP11(const HostPortPair& server,
                                                 SSLConfig* ssl_config) {
   if (RequiresHTTP11(server)) {
     ForceHTTP11(ssl_config);
   }
 }
 
-bool HttpServerPropertiesImpl::HasAlternateProtocol(
-    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 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(host, canonical_suffixes_[i], false)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
-AlternateProtocolInfo
-HttpServerPropertiesImpl::GetAlternateProtocol(
+AlternateProtocolInfo HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
-  DCHECK(HasAlternateProtocol(server));
-
   AlternateProtocolMap::const_iterator it =
       GetAlternateProtocolIterator(server);
-  if (it != alternate_protocol_map_.end())
+  if (it != alternate_protocol_map_.end() &&
+      it->second.probability >= alternate_protocol_probability_threshold_)
     return it->second;
 
-  // We must be forcing an alternate.
-  DCHECK(g_forced_alternate_protocol);
-  return *g_forced_alternate_protocol;
+  if (g_forced_alternate_protocol)
+    return *g_forced_alternate_protocol;
+
+  AlternateProtocolInfo uninitialized_alternate_protocol;
+  return uninitialized_alternate_protocol;
 }
 
 void HttpServerPropertiesImpl::SetAlternateProtocol(
     const HostPortPair& server,
     uint16 alternate_port,
     AlternateProtocol alternate_protocol,
     double alternate_probability) {
 
   AlternateProtocolInfo alternate(alternate_port,
                                   alternate_protocol,
@@ skipping 38 matching lines @@
       HostPortPair canonical_host(canonical_suffix, server.port());
       canonical_host_to_origin_map_[canonical_host] = server;
       break;
     }
   }
 }
 
 void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
     const HostPortPair& server) {
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
+  const AlternateProtocolInfo alternate = GetAlternateProtocol(server);
   if (it == alternate_protocol_map_.end()) {
-    if (!HasAlternateProtocol(server)) {
+    if (alternate.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
       LOG(DFATAL) << "Trying to mark unknown alternate protocol broken.";
       return;
     }
     // This server's alternate protocol information is coming from a canonical
     // server. Add an entry in the map for this server explicitly so that
     // it can be marked as broken.
-    it = alternate_protocol_map_.Put(server, GetAlternateProtocol(server));
+    it = alternate_protocol_map_.Put(server, alternate);
   }
   it->second.is_broken = true;
-  int count = ++broken_alternate_protocol_map_[server];
+  const BrokenAlternateProtocolEntry entry(server, alternate.port,
+                                           alternate.protocol);
+  int count = ++broken_alternate_protocol_map_[entry];
   base::TimeDelta delay =
       base::TimeDelta::FromSeconds(kBrokenAlternateProtocolDelaySecs);
-  BrokenAlternateProtocolEntry entry;
-  entry.server = server;
-  entry.when = base::TimeTicks::Now() + delay * (1 << (count - 1));
-  broken_alternate_protocol_list_.push_back(entry);
+  base::TimeTicks when = base::TimeTicks::Now() + delay * (1 << (count - 1));
+  broken_alternate_protocol_list_.push_back(
+      BrokenAlternateProtocolEntryWithTime(entry, when));
 
   // 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.
   // 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);
+  const AlternateProtocolInfo alternate_protocol = GetAlternateProtocol(server);
+  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+    return false;
+  const BrokenAlternateProtocolEntry entry(server, alternate_protocol.port,
+                                           alternate_protocol.protocol);
+  return ContainsKey(broken_alternate_protocol_map_, entry);
 }
 
 void HttpServerPropertiesImpl::ConfirmAlternateProtocol(
     const HostPortPair& server) {
-  broken_alternate_protocol_map_.erase(server);
+  const AlternateProtocolInfo alternate_protocol = GetAlternateProtocol(server);
+  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+    return;
+  const BrokenAlternateProtocolEntry entry(server, alternate_protocol.port,
+                                           alternate_protocol.protocol);
+  broken_alternate_protocol_map_.erase(entry);
 }
 
 void HttpServerPropertiesImpl::ClearAlternateProtocol(
     const HostPortPair& server) {
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Peek(server);
   if (it != alternate_protocol_map_.end())
     alternate_protocol_map_.Erase(it);
 
   RemoveCanonicalHost(server);
 }
@@ skipping 43 matching lines @@
 
 void HttpServerPropertiesImpl::ClearAllSpdySettings() {
   spdy_settings_map_.Clear();
 }
 
 const SpdySettingsMap&
 HttpServerPropertiesImpl::spdy_settings_map() const {
   return spdy_settings_map_;
 }
 
-SupportsQuic HttpServerPropertiesImpl::GetSupportsQuic(
-    const HostPortPair& host_port_pair) const {
-  SupportsQuicMap::const_iterator it = supports_quic_map_.find(host_port_pair);
-  if (it == supports_quic_map_.end()) {
-    CR_DEFINE_STATIC_LOCAL(SupportsQuic, kEmptySupportsQuic, ());
-    return kEmptySupportsQuic;
-  }
-  return it->second;
+bool HttpServerPropertiesImpl::GetSupportsQuic(
+    IPAddressNumber* last_address) const {
+  if (last_quic_address_.empty())
+    return false;
+
+  *last_address = last_quic_address_;
+  return true;
 }
 
-void HttpServerPropertiesImpl::SetSupportsQuic(
-    const HostPortPair& host_port_pair,
-    bool used_quic,
-    const std::string& address) {
-  SupportsQuic supports_quic(used_quic, address);
-  supports_quic_map_.insert(std::make_pair(host_port_pair, supports_quic));
-}
-
-const SupportsQuicMap& HttpServerPropertiesImpl::supports_quic_map() const {
-  return supports_quic_map_;
+void HttpServerPropertiesImpl::SetSupportsQuic(bool used_quic,
+                                               const IPAddressNumber& address) {
+  if (!used_quic) {
+    last_quic_address_.clear();
+  } else {
+    last_quic_address_ = address;
+  }
 }
 
 void HttpServerPropertiesImpl::SetServerNetworkStats(
     const HostPortPair& host_port_pair,
     ServerNetworkStats stats) {
   server_network_stats_map_.Put(host_port_pair, stats);
 }
 
 const ServerNetworkStats* HttpServerPropertiesImpl::GetServerNetworkStats(
     const HostPortPair& host_port_pair) {
@@ skipping 50 matching lines @@
 
   if (!canonical->second.Equals(server))
     return;
 
   canonical_host_to_origin_map_.erase(canonical->first);
 }
 
 void HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings() {
   base::TimeTicks now = base::TimeTicks::Now();
   while (!broken_alternate_protocol_list_.empty()) {
-    BrokenAlternateProtocolEntry entry =
+    BrokenAlternateProtocolEntryWithTime entry_with_time =
         broken_alternate_protocol_list_.front();
-    if (now < entry.when) {
+    if (now < entry_with_time.when) {
       break;
     }
 
+    const BrokenAlternateProtocolEntry& entry =
+        entry_with_time.broken_alternate_protocol_entry;
     ClearAlternateProtocol(entry.server);
     broken_alternate_protocol_list_.pop_front();
   }
   ScheduleBrokenAlternateProtocolMappingsExpiration();
 }
 
 void
 HttpServerPropertiesImpl::ScheduleBrokenAlternateProtocolMappingsExpiration() {
   if (broken_alternate_protocol_list_.empty()) {
     return;
   }
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks when = broken_alternate_protocol_list_.front().when;
   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