Make HttpServerProperties::GetSupportsQuic not host-specific.

Review URL: https://codereview.chromium.org/892203004

Cr-Commit-Position: refs/heads/master@{#314671}

net/http/http_server_properties.h

@@ -13,6 +13,7 @@
 #include "base/time/time.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
+#include "net/base/net_util.h"
 #include "net/quic/quic_bandwidth.h"
 #include "net/socket/next_proto.h"
 #include "net/spdy/spdy_framer.h"  // TODO(willchan): Reconsider this.
@@ -147,7 +148,6 @@ struct NET_EXPORT ServerNetworkStats {
 typedef base::MRUCache<
     HostPortPair, AlternateProtocolInfo> AlternateProtocolMap;
 typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
-typedef std::map<HostPortPair, SupportsQuic> SupportsQuicMap;
 typedef base::MRUCache<HostPortPair, ServerNetworkStats> ServerNetworkStatsMap;
 
 extern const char kAlternateProtocolHeader[];
@@ -247,15 +247,10 @@ class NET_EXPORT HttpServerProperties {
   // Returns all persistent SPDY settings.
   virtual const SpdySettingsMap& spdy_settings_map() const = 0;
 
-  // TODO(rtenneti): Make SupportsQuic a global (instead of per host_port_pair).
-  virtual SupportsQuic GetSupportsQuic(
-      const HostPortPair& host_port_pair) const = 0;
+  virtual bool GetSupportsQuic(IPAddressNumber* last_address) const = 0;
 
-  virtual void SetSupportsQuic(const HostPortPair& host_port_pair,
-                               bool used_quic,
-                               const std::string& address) = 0;
-
-  virtual const SupportsQuicMap& supports_quic_map() const = 0;
+  virtual void SetSupportsQuic(bool used_quic,
+                               const IPAddressNumber& last_address) = 0;
 
   virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
                                      ServerNetworkStats stats) = 0;

net/http/http_server_properties_impl.cc

@@ -102,12 +102,9 @@ void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
 }
 
 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(
@@ -164,7 +161,7 @@ void HttpServerPropertiesImpl::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();
 }
 
@@ -411,26 +408,22 @@ 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;
 
-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));
+  *last_address = last_quic_address_;
+  return true;
 }
 
-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(

net/http/http_server_properties_impl.h

@@ -43,7 +43,7 @@ class NET_EXPORT HttpServerPropertiesImpl
 
   void InitializeSpdySettingsServers(SpdySettingsMap* spdy_settings_map);
 
-  void InitializeSupportsQuic(SupportsQuicMap* supports_quic_map);
+  void InitializeSupportsQuic(IPAddressNumber* last_address);
 
   void InitializeServerNetworkStats(
       ServerNetworkStatsMap* server_network_stats_map);
@@ -100,12 +100,8 @@ class NET_EXPORT HttpServerPropertiesImpl
   void ClearSpdySettings(const HostPortPair& host_port_pair) override;
   void ClearAllSpdySettings() override;
   const SpdySettingsMap& spdy_settings_map() const override;
-  SupportsQuic GetSupportsQuic(
-      const HostPortPair& host_port_pair) const override;
-  void SetSupportsQuic(const HostPortPair& host_port_pair,
-                       bool used_quic,
-                       const std::string& address) override;
-  const SupportsQuicMap& supports_quic_map() const override;
+  bool GetSupportsQuic(IPAddressNumber* last_address) const override;
+  void SetSupportsQuic(bool used_quic, const IPAddressNumber& address) override;
   void SetServerNetworkStats(const HostPortPair& host_port_pair,
                              ServerNetworkStats stats) override;
   const ServerNetworkStats* GetServerNetworkStats(
@@ -148,8 +144,8 @@ class NET_EXPORT HttpServerPropertiesImpl
   BrokenAlternateProtocolList broken_alternate_protocol_list_;
   BrokenAlternateProtocolMap broken_alternate_protocol_map_;
 
+  IPAddressNumber last_quic_address_;
   SpdySettingsMap spdy_settings_map_;
-  SupportsQuicMap supports_quic_map_;
   ServerNetworkStatsMap server_network_stats_map_;
   // Contains a map of servers which could share the same alternate protocol.
   // Map from a Canonical host/port (host is some postfix of host names) to an

net/http/http_server_properties_impl_unittest.cc

@@ -680,37 +680,37 @@ typedef HttpServerPropertiesImplTest SupportsQuicServerPropertiesTest;
 TEST_F(SupportsQuicServerPropertiesTest, Initialize) {
   HostPortPair quic_server_google("www.google.com", 443);
 
-  // Check by initializing empty SupportsQuic.
-  SupportsQuicMap supports_quic_map;
-  impl_.InitializeSupportsQuic(&supports_quic_map);
-  SupportsQuic supports_quic = impl_.GetSupportsQuic(quic_server_google);
-  EXPECT_FALSE(supports_quic.used_quic);
-  EXPECT_EQ("", supports_quic.address);
+  // Check by initializing empty address.
+  IPAddressNumber initial_address;
+  impl_.InitializeSupportsQuic(&initial_address);
 
-  // Check by initializing with www.google.com:443.
-  SupportsQuic supports_quic1(true, "foo");
-  supports_quic_map.insert(std::make_pair(quic_server_google, supports_quic1));
-  impl_.InitializeSupportsQuic(&supports_quic_map);
+  IPAddressNumber address;
+  EXPECT_FALSE(impl_.GetSupportsQuic(&address));
+  EXPECT_TRUE(address.empty());
+
+  // Check by initializing with a valid address.
+  CHECK(ParseIPLiteralToNumber("127.0.0.1", &initial_address));
+  impl_.InitializeSupportsQuic(&initial_address);
 
-  SupportsQuic supports_quic2 = impl_.GetSupportsQuic(quic_server_google);
-  EXPECT_TRUE(supports_quic2.used_quic);
-  EXPECT_EQ("foo", supports_quic2.address);
+  EXPECT_TRUE(impl_.GetSupportsQuic(&address));
+  EXPECT_EQ(initial_address, address);
 }
 
 TEST_F(SupportsQuicServerPropertiesTest, SetSupportsQuic) {
-  HostPortPair test_host_port_pair("foo", 80);
-  SupportsQuic supports_quic = impl_.GetSupportsQuic(test_host_port_pair);
-  EXPECT_FALSE(supports_quic.used_quic);
-  EXPECT_EQ("", supports_quic.address);
-  impl_.SetSupportsQuic(test_host_port_pair, true, "foo");
-  SupportsQuic supports_quic1 = impl_.GetSupportsQuic(test_host_port_pair);
-  EXPECT_TRUE(supports_quic1.used_quic);
-  EXPECT_EQ("foo", supports_quic1.address);
+  IPAddressNumber address;
+  EXPECT_FALSE(impl_.GetSupportsQuic(&address));
+  EXPECT_TRUE(address.empty());
+
+  IPAddressNumber actual_address;
+  CHECK(ParseIPLiteralToNumber("127.0.0.1", &actual_address));
+  impl_.SetSupportsQuic(true, actual_address);
+
+  EXPECT_TRUE(impl_.GetSupportsQuic(&address));
+  EXPECT_EQ(actual_address, address);
 
   impl_.Clear();
-  SupportsQuic supports_quic2 = impl_.GetSupportsQuic(test_host_port_pair);
-  EXPECT_FALSE(supports_quic2.used_quic);
-  EXPECT_EQ("", supports_quic2.address);
+
+  EXPECT_FALSE(impl_.GetSupportsQuic(&address));
 }
 
 typedef HttpServerPropertiesImplTest ServerNetworkStatsServerPropertiesTest;

net/http/http_server_properties_manager.h

@@ -107,12 +107,9 @@ class NET_EXPORT HttpServerPropertiesManager : public HttpServerProperties {
   void ClearSpdySettings(const HostPortPair& host_port_pair) override;
   void ClearAllSpdySettings() override;
   const SpdySettingsMap& spdy_settings_map() const override;
-  SupportsQuic GetSupportsQuic(
-      const HostPortPair& host_port_pair) const override;
-  void SetSupportsQuic(const HostPortPair& host_port_pair,
-                       bool used_quic,
-                       const std::string& address) override;
-  const SupportsQuicMap& supports_quic_map() const override;
+  bool GetSupportsQuic(IPAddressNumber* last_address) const override;
+  void SetSupportsQuic(bool used_quic,
+                       const IPAddressNumber& last_address) override;
   void SetServerNetworkStats(const HostPortPair& host_port_pair,
                              ServerNetworkStats stats) override;
   const ServerNetworkStats* GetServerNetworkStats(
@@ -144,7 +141,7 @@ class NET_EXPORT HttpServerPropertiesManager : public HttpServerProperties {
       std::vector<std::string>* spdy_servers,
       SpdySettingsMap* spdy_settings_map,
       AlternateProtocolMap* alternate_protocol_map,
-      SupportsQuicMap* supports_quic_map,
+      IPAddressNumber* last_quic_address,
       ServerNetworkStatsMap* server_network_stats_map,
       bool detected_corrupted_prefs);
 
@@ -173,22 +170,21 @@ class NET_EXPORT HttpServerPropertiesManager : public HttpServerProperties {
   void UpdatePrefsOnPrefThread(base::ListValue* spdy_server_list,
                                SpdySettingsMap* spdy_settings_map,
                                AlternateProtocolMap* alternate_protocol_map,
-                               SupportsQuicMap* supports_quic_map,
+                               IPAddressNumber* last_quic_address,
                                ServerNetworkStatsMap* server_network_stats_map,
                                const base::Closure& completion);
 
  private:
   void OnHttpServerPropertiesChanged();
 
+  bool ReadSupportsQuic(const base::DictionaryValue& server_dict,
+                        IPAddressNumber* last_quic_address);
   void AddToSpdySettingsMap(const HostPortPair& server,
                             const base::DictionaryValue& server_dict,
                             SpdySettingsMap* spdy_settings_map);
   bool AddToAlternateProtocolMap(const HostPortPair& server,
                                  const base::DictionaryValue& server_dict,
                                  AlternateProtocolMap* alternate_protocol_map);
-  bool AddToSupportsQuicMap(const HostPortPair& server,
-                            const base::DictionaryValue& server_dict,
-                            SupportsQuicMap* supports_quic_map);
   bool AddToNetworkStatsMap(const HostPortPair& server,
                             const base::DictionaryValue& server_dict,
                             ServerNetworkStatsMap* network_stats_map);
@@ -198,12 +194,14 @@ class NET_EXPORT HttpServerPropertiesManager : public HttpServerProperties {
   void SaveAlternateProtocolToServerPrefs(
       const AlternateProtocolInfo* port_alternate_protocol,
       base::DictionaryValue* server_pref_dict);
-  void SaveSupportsQuicToServerPrefs(const SupportsQuic* supports_quic,
-                                     base::DictionaryValue* server_pref_dict);
   void SaveNetworkStatsToServerPrefs(
       const ServerNetworkStats* server_network_stats,
       base::DictionaryValue* server_pref_dict);
 
+  void SaveSupportsQuicToPrefs(
+      const IPAddressNumber* last_quic_address,
+      base::DictionaryValue* http_server_properties_dict);
+
   // -----------
   // Pref thread
   // -----------

net/http/http_server_properties_manager_unittest.cc

@@ -74,14 +74,14 @@ class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
                void(std::vector<std::string>* spdy_servers,
                     SpdySettingsMap* spdy_settings_map,
                     AlternateProtocolMap* alternate_protocol_map,
-                    SupportsQuicMap* supports_quic_map,
+                    IPAddressNumber* last_quic_address,
                     ServerNetworkStatsMap* server_network_stats_map,
                     bool detected_corrupted_prefs));
   MOCK_METHOD5(UpdatePrefsOnPref,
                void(base::ListValue* spdy_server_list,
                     SpdySettingsMap* spdy_settings_map,
                     AlternateProtocolMap* alternate_protocol_map,
-                    SupportsQuicMap* supports_quic_map,
+                    IPAddressNumber* last_quic_address,
                     ServerNetworkStatsMap* server_network_stats_map));
 
  private:
@@ -169,12 +169,6 @@ TEST_F(HttpServerPropertiesManagerTest,
   server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
                                             alternate_protocol);
 
-  // Set up SupportsQuic for www.google.com:80.
-  base::DictionaryValue* supports_quic = new base::DictionaryValue;
-  supports_quic->SetBoolean("used_quic", true);
-  supports_quic->SetString("address", "foo");
-  server_pref_dict->SetWithoutPathExpansion("supports_quic", supports_quic);
-
   // Set up ServerNetworkStats for www.google.com:80.
   base::DictionaryValue* stats = new base::DictionaryValue;
   stats->SetInteger("srtt", 10);
@@ -198,12 +192,6 @@ TEST_F(HttpServerPropertiesManagerTest,
   server_pref_dict1->SetWithoutPathExpansion("alternate_protocol",
                                              alternate_protocol1);
 
-  // Set up SupportsQuic for mail.google.com:80
-  base::DictionaryValue* supports_quic1 = new base::DictionaryValue;
-  supports_quic1->SetBoolean("used_quic", false);
-  supports_quic1->SetString("address", "bar");
-  server_pref_dict1->SetWithoutPathExpansion("supports_quic", supports_quic1);
-
   // Set up ServerNetworkStats for mail.google.com:80.
   base::DictionaryValue* stats1 = new base::DictionaryValue;
   stats1->SetInteger("srtt", 20);
@@ -216,6 +204,11 @@ TEST_F(HttpServerPropertiesManagerTest,
       new base::DictionaryValue;
   HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
   http_server_properties_dict->SetWithoutPathExpansion("servers", servers_dict);
+  base::DictionaryValue* supports_quic = new base::DictionaryValue;
+  supports_quic->SetBoolean("used_quic", true);
+  supports_quic->SetString("address", "127.0.0.1");
+  http_server_properties_dict->SetWithoutPathExpansion("supports_quic",
+                                                       supports_quic);
 
   // Set the same value for kHttpServerProperties multiple times.
   pref_service_.SetManagedPref(kTestHttpServerProperties,
@@ -246,13 +239,9 @@ TEST_F(HttpServerPropertiesManagerTest,
   EXPECT_EQ(NPN_SPDY_3_1, port_alternate_protocol.protocol);
 
   // Verify SupportsQuic.
-  SupportsQuic supports_quic2 =
-      http_server_props_manager_->GetSupportsQuic(google_server);
-  EXPECT_TRUE(supports_quic2.used_quic);
-  EXPECT_EQ("foo", supports_quic2.address);
-  supports_quic2 = http_server_props_manager_->GetSupportsQuic(mail_server);
-  EXPECT_FALSE(supports_quic2.used_quic);
-  EXPECT_EQ("bar", supports_quic2.address);
+  IPAddressNumber last_address;
+  EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&last_address));
+  EXPECT_EQ("127.0.0.1", IPAddressToString(last_address));
 
   // Verify ServerNetworkStats.
   const ServerNetworkStats* stats2 =
@@ -280,12 +269,6 @@ TEST_F(HttpServerPropertiesManagerTest, BadCachedHostPortPair) {
   server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
                                             alternate_protocol);
 
-  // Set up SupportsQuic for www.google.com:65536.
-  base::DictionaryValue* supports_quic = new base::DictionaryValue;
-  supports_quic->SetBoolean("used_quic", true);
-  supports_quic->SetString("address", "foo");
-  server_pref_dict->SetWithoutPathExpansion("supports_quic", supports_quic);
-
   // Set up ServerNetworkStats for www.google.com:65536.
   base::DictionaryValue* stats = new base::DictionaryValue;
   stats->SetInteger("srtt", 10);
@@ -313,9 +296,6 @@ TEST_F(HttpServerPropertiesManagerTest, BadCachedHostPortPair) {
       HostPortPair::FromString("www.google.com:65536")));
   EXPECT_FALSE(
       HasAlternateProtocol(HostPortPair::FromString("www.google.com:65536")));
-  SupportsQuic supports_quic2 = http_server_props_manager_->GetSupportsQuic(
-      HostPortPair::FromString("www.google.com:65536"));
-  EXPECT_FALSE(supports_quic2.used_quic);
   const ServerNetworkStats* stats1 =
       http_server_props_manager_->GetServerNetworkStats(
           HostPortPair::FromString("www.google.com:65536"));
@@ -503,21 +483,19 @@ TEST_F(HttpServerPropertiesManagerTest, GetAlternateProtocol) {
 TEST_F(HttpServerPropertiesManagerTest, SupportsQuic) {
   ExpectPrefsUpdate();
 
-  HostPortPair quic_server_mail("mail.google.com", 80);
-  SupportsQuic supports_quic =
-      http_server_props_manager_->GetSupportsQuic(quic_server_mail);
-  EXPECT_FALSE(supports_quic.used_quic);
-  EXPECT_EQ("", supports_quic.address);
-  http_server_props_manager_->SetSupportsQuic(quic_server_mail, true, "foo");
+  IPAddressNumber address;
+  EXPECT_FALSE(http_server_props_manager_->GetSupportsQuic(&address));
+
+  IPAddressNumber actual_address;
+  CHECK(ParseIPLiteralToNumber("127.0.0.1", &actual_address));
+  http_server_props_manager_->SetSupportsQuic(true, actual_address);
 
   // Run the task.
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
-  SupportsQuic supports_quic1 =
-      http_server_props_manager_->GetSupportsQuic(quic_server_mail);
-  EXPECT_TRUE(supports_quic1.used_quic);
-  EXPECT_EQ("foo", supports_quic1.address);
+  EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
+  EXPECT_EQ(actual_address, address);
 }
 
 TEST_F(HttpServerPropertiesManagerTest, ServerNetworkStats) {
@@ -547,7 +525,9 @@ TEST_F(HttpServerPropertiesManagerTest, Clear) {
   http_server_props_manager_->SetSupportsSpdy(spdy_server_mail, true);
   http_server_props_manager_->SetAlternateProtocol(spdy_server_mail, 443,
                                                    NPN_SPDY_3, 1.0);
-  http_server_props_manager_->SetSupportsQuic(spdy_server_mail, true, "foo");
+  IPAddressNumber actual_address;
+  CHECK(ParseIPLiteralToNumber("127.0.0.1", &actual_address));
+  http_server_props_manager_->SetSupportsQuic(true, actual_address);
   ServerNetworkStats stats;
   stats.srtt = base::TimeDelta::FromMicroseconds(10);
   http_server_props_manager_->SetServerNetworkStats(spdy_server_mail, stats);
@@ -564,10 +544,9 @@ TEST_F(HttpServerPropertiesManagerTest, Clear) {
   EXPECT_TRUE(
       http_server_props_manager_->SupportsRequestPriority(spdy_server_mail));
   EXPECT_TRUE(HasAlternateProtocol(spdy_server_mail));
-  SupportsQuic supports_quic =
-      http_server_props_manager_->GetSupportsQuic(spdy_server_mail);
-  EXPECT_TRUE(supports_quic.used_quic);
-  EXPECT_EQ("foo", supports_quic.address);
+  IPAddressNumber address;
+  EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
+  EXPECT_EQ(actual_address, address);
   const ServerNetworkStats* stats1 =
       http_server_props_manager_->GetServerNetworkStats(spdy_server_mail);
   EXPECT_EQ(10, stats1->srtt.ToInternalValue());
@@ -593,10 +572,7 @@ TEST_F(HttpServerPropertiesManagerTest, Clear) {
   EXPECT_FALSE(
       http_server_props_manager_->SupportsRequestPriority(spdy_server_mail));
   EXPECT_FALSE(HasAlternateProtocol(spdy_server_mail));
-  SupportsQuic supports_quic1 =
-      http_server_props_manager_->GetSupportsQuic(spdy_server_mail);
-  EXPECT_FALSE(supports_quic1.used_quic);
-  EXPECT_EQ("", supports_quic1.address);
+  EXPECT_FALSE(http_server_props_manager_->GetSupportsQuic(&address));
   const ServerNetworkStats* stats2 =
       http_server_props_manager_->GetServerNetworkStats(spdy_server_mail);
   EXPECT_EQ(NULL, stats2);
@@ -629,11 +605,6 @@ TEST_F(HttpServerPropertiesManagerTest, BadSupportsQuic) {
 
   // Set the preference for mail.google.com server.
   base::DictionaryValue* server_pref_dict1 = new base::DictionaryValue;
-  // Set up SupportsQuic for mail.google.com:80
-  base::DictionaryValue* supports_quic = new base::DictionaryValue;
-  supports_quic->SetBoolean("used_quic", true);
-  supports_quic->SetString("address", "bar");
-  server_pref_dict1->SetWithoutPathExpansion("supports_quic", supports_quic);
 
   // Set the server preference for mail.google.com:80.
   servers_dict->SetWithoutPathExpansion("mail.google.com:80",
@@ -644,6 +615,13 @@ TEST_F(HttpServerPropertiesManagerTest, BadSupportsQuic) {
   HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
   http_server_properties_dict->SetWithoutPathExpansion("servers", servers_dict);
 
+  // Set up SupportsQuic for 127.0.0.1
+  base::DictionaryValue* supports_quic = new base::DictionaryValue;
+  supports_quic->SetBoolean("used_quic", true);
+  supports_quic->SetString("address", "127.0.0.1");
+  http_server_properties_dict->SetWithoutPathExpansion("supports_quic",
+                                                       supports_quic);
+
   // Set up the pref.
   pref_service_.SetManagedPref(kTestHttpServerProperties,
                                http_server_properties_dict);
@@ -662,10 +640,9 @@ TEST_F(HttpServerPropertiesManagerTest, BadSupportsQuic) {
   }
 
   // Verify SupportsQuic.
-  SupportsQuic supports_quic1 = http_server_props_manager_->GetSupportsQuic(
-      HostPortPair::FromString("mail.google.com:80"));
-  EXPECT_TRUE(supports_quic1.used_quic);
-  EXPECT_EQ("bar", supports_quic1.address);
+  IPAddressNumber address;
+  ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
+  EXPECT_EQ("127.0.0.1", IPAddressToString(address));
 }
 
 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache0) {

net/quic/quic_stream_factory.cc

@@ -63,9 +63,6 @@ const int32 kInitialReceiveWindowSize = 10 * 1024 * 1024;  // 10MB
 // Set the maximum number of undecryptable packets the connection will store.
 const int32 kMaxUndecryptablePackets = 100;
 
-const char kDummyHostname[] = "quic.global.props";
-const uint16 kDummyPort = 0;
-
 void HistogramCreateSessionFailure(enum CreateSessionFailure error) {
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error,
                             CREATION_ERROR_MAX);
@@ -619,11 +616,8 @@ QuicStreamFactory::~QuicStreamFactory() {
 void QuicStreamFactory::set_require_confirmation(bool require_confirmation) {
   require_confirmation_ = require_confirmation;
   if (http_server_properties_ && (!(local_address_ == IPEndPoint()))) {
-    // TODO(rtenneti): Delete host_port_pair and persist data in globals.
-    HostPortPair host_port_pair(kDummyHostname, kDummyPort);
-    http_server_properties_->SetSupportsQuic(
-        host_port_pair, !require_confirmation,
-        local_address_.ToStringWithoutPort());
+    http_server_properties_->SetSupportsQuic(!require_confirmation,
+                                             local_address_.address());
   }
 }
 
@@ -1002,11 +996,9 @@ int QuicStreamFactory::CreateSession(
   socket->GetLocalAddress(&local_address_);
   if (check_persisted_supports_quic_ && http_server_properties_) {
     check_persisted_supports_quic_ = false;
-    // TODO(rtenneti): Delete host_port_pair and persist data in globals.
-    HostPortPair host_port_pair(kDummyHostname, kDummyPort);
-    SupportsQuic supports_quic(true, local_address_.ToStringWithoutPort());
-    if (http_server_properties_->GetSupportsQuic(
-            host_port_pair).Equals(supports_quic)) {
+    IPAddressNumber last_address;
+    if (http_server_properties_->GetSupportsQuic(&last_address) &&
+        last_address == local_address_.address()) {
       require_confirmation_ = false;
     }
   }