Make HttpServerProperties::GetSupportsQuic not host-specific.

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 =
@@ skipping 226 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 79 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