Introduce AlternativeServiceInfo.

net/http/http_server_properties_manager_unittest.cc

 // Copyright 2014 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_manager.h"
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 56 matching lines @@
   void UpdatePrefsFromCacheOnNetworkThreadConcrete(
       const base::Closure& callback) {
     HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread(callback);
   }
 
   MOCK_METHOD0(UpdateCacheFromPrefsOnPrefThread, void());
   MOCK_METHOD1(UpdatePrefsFromCacheOnNetworkThread, void(const base::Closure&));
   MOCK_METHOD6(UpdateCacheFromPrefsOnNetworkThread,
                void(std::vector<std::string>* spdy_servers,
                     SpdySettingsMap* spdy_settings_map,
-                    AlternateProtocolMap* alternate_protocol_map,
+                    AlternativeServiceMap* alternative_service_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,
+                    AlternativeServiceMap* alternative_service_map,
                     IPAddressNumber* last_quic_address,
                     ServerNetworkStatsMap* server_network_stats_map));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestingHttpServerPropertiesManager);
 };
 
 class HttpServerPropertiesManagerTest : public testing::Test {
  protected:
   HttpServerPropertiesManagerTest() {}
@@ skipping 61 matching lines @@
   // Set up the prefs for www.google.com:80 and mail.google.com:80 and then set
   // it twice. Only expect a single cache update.
 
   base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
   HostPortPair google_server("www.google.com", 80);
   HostPortPair mail_server("mail.google.com", 80);
 
   // Set supports_spdy for www.google.com:80.
   server_pref_dict->SetBoolean("supports_spdy", true);
 
-  // Set up alternate_protocol for www.google.com:80.
-  base::DictionaryValue* alternate_protocol = new base::DictionaryValue;
-  alternate_protocol->SetInteger("port", 443);
-  alternate_protocol->SetString("protocol_str", "npn-spdy/3");
-  server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
-                                            alternate_protocol);
+  // Set up alternative_service for www.google.com:80.
+  base::DictionaryValue* alternative_service_dict = new base::DictionaryValue;
+  alternative_service_dict->SetString("protocol_str", "npn-spdy/3");
+  alternative_service_dict->SetString("host", "maps.google.com");
+  alternative_service_dict->SetInteger("port", 443);
+  base::ListValue* alternative_service_list = new base::ListValue;
+  alternative_service_list->Append(alternative_service_dict);
+  server_pref_dict->SetWithoutPathExpansion("alternative_service",
+                                            alternative_service_list);
 
   // Set up ServerNetworkStats for www.google.com:80.
   base::DictionaryValue* stats = new base::DictionaryValue;
   stats->SetInteger("srtt", 10);
   server_pref_dict->SetWithoutPathExpansion("network_stats", stats);
 
   // Set the server preference for www.google.com:80.
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   servers_dict->SetWithoutPathExpansion("www.google.com:80", server_pref_dict);
 
   // Set the preference for mail.google.com server.
   base::DictionaryValue* server_pref_dict1 = new base::DictionaryValue;
 
   // Set supports_spdy for mail.google.com:80
   server_pref_dict1->SetBoolean("supports_spdy", true);
 
-  // Set up alternate_protocol for mail.google.com:80
-  base::DictionaryValue* alternate_protocol1 = new base::DictionaryValue;
-  alternate_protocol1->SetInteger("port", 444);
-  alternate_protocol1->SetString("protocol_str", "npn-spdy/3.1");
-
+  // Set up alternate_protocol for mail.google.com:80 to test migration to
+  // alternative-service.
+  base::DictionaryValue* alternate_protocol_dict = new base::DictionaryValue;
+  alternate_protocol_dict->SetString("protocol_str", "npn-spdy/3.1");
+  alternate_protocol_dict->SetInteger("port", 444);
   server_pref_dict1->SetWithoutPathExpansion("alternate_protocol",
-                                             alternate_protocol1);
+                                             alternate_protocol_dict);
 
   // Set up ServerNetworkStats for mail.google.com:80.
   base::DictionaryValue* stats1 = new base::DictionaryValue;
   stats1->SetInteger("srtt", 20);
   server_pref_dict1->SetWithoutPathExpansion("network_stats", stats1);
   // Set the server preference for mail.google.com:80.
   servers_dict->SetWithoutPathExpansion("mail.google.com:80",
                                         server_pref_dict1);
 
   base::DictionaryValue* http_server_properties_dict =
@@ skipping 17 matching lines @@
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   // Verify SupportsSpdy.
   EXPECT_TRUE(
       http_server_props_manager_->SupportsRequestPriority(google_server));
   EXPECT_TRUE(http_server_props_manager_->SupportsRequestPriority(mail_server));
   EXPECT_FALSE(http_server_props_manager_->SupportsRequestPriority(
       HostPortPair::FromString("foo.google.com:1337")));
 
-  // Verify AlternateProtocol.
+  // Verify alternative service.
   AlternativeService alternative_service =
       http_server_props_manager_->GetAlternativeService(google_server);
+  EXPECT_EQ(NPN_SPDY_3, alternative_service.protocol);
+  EXPECT_EQ("maps.google.com", alternative_service.host);
   EXPECT_EQ(443, alternative_service.port);
-  EXPECT_EQ(NPN_SPDY_3, alternative_service.protocol);
   alternative_service =
       http_server_props_manager_->GetAlternativeService(mail_server);
+  EXPECT_EQ(NPN_SPDY_3_1, alternative_service.protocol);
+  EXPECT_EQ("mail.google.com", alternative_service.host);
   EXPECT_EQ(444, alternative_service.port);
-  EXPECT_EQ(NPN_SPDY_3_1, alternative_service.protocol);
 
   // Verify SupportsQuic.
   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 =
       http_server_props_manager_->GetServerNetworkStats(google_server);
   EXPECT_EQ(10, stats2->srtt.ToInternalValue());
   const ServerNetworkStats* stats3 =
       http_server_props_manager_->GetServerNetworkStats(mail_server);
   EXPECT_EQ(20, stats3->srtt.ToInternalValue());
 }
 
 TEST_F(HttpServerPropertiesManagerTest, BadCachedHostPortPair) {
   ExpectCacheUpdate();
   // The prefs are automaticalls updated in the case corruption is detected.
   ExpectPrefsUpdate();
 
   base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
   // Set supports_spdy for www.google.com:65536.
   server_pref_dict->SetBoolean("supports_spdy", true);
 
-  // Set up alternate_protocol for www.google.com:65536.
-  base::DictionaryValue* alternate_protocol = new base::DictionaryValue;
-  alternate_protocol->SetInteger("port", 80);
-  alternate_protocol->SetString("protocol_str", "npn-spdy/3");
-  server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
-                                            alternate_protocol);
+  // Set up alternative_service for www.google.com:65536.
+
+  base::DictionaryValue* alternative_service_dict = new base::DictionaryValue;
+  alternative_service_dict->SetString("protocol_str", "npn-spdy/3");
+  alternative_service_dict->SetInteger("port", 80);
+  base::ListValue* alternative_service_list = new base::ListValue;
+  alternative_service_list->Append(alternative_service_dict);
+  server_pref_dict->SetWithoutPathExpansion("alternative_service",
+                                            alternative_service_list);
 
   // Set up ServerNetworkStats for www.google.com:65536.
   base::DictionaryValue* stats = new base::DictionaryValue;
   stats->SetInteger("srtt", 10);
   server_pref_dict->SetWithoutPathExpansion("network_stats", stats);
 
   // Set the server preference for www.google.com:65536.
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   servers_dict->SetWithoutPathExpansion("www.google.com:65536",
                                         server_pref_dict);
@@ skipping 24 matching lines @@
 TEST_F(HttpServerPropertiesManagerTest, BadCachedAltProtocolPort) {
   ExpectCacheUpdate();
   // The prefs are automaticalls updated in the case corruption is detected.
   ExpectPrefsUpdate();
 
   base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
   // Set supports_spdy for www.google.com:80.
   server_pref_dict->SetBoolean("supports_spdy", true);
 
-  // Set up alternate_protocol for www.google.com:80.
-  base::DictionaryValue* alternate_protocol = new base::DictionaryValue;
-  alternate_protocol->SetInteger("port", 65536);
-  alternate_protocol->SetString("protocol_str", "npn-spdy/3");
-  server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
-                                            alternate_protocol);
+  // Set up alternative_service for www.google.com:80.
+  base::DictionaryValue* alternative_service_dict = new base::DictionaryValue;
+  alternative_service_dict->SetString("protocol_str", "npn-spdy/3");
+  alternative_service_dict->SetInteger("port", 65536);
+  base::ListValue* alternative_service_list = new base::ListValue;
+  alternative_service_list->Append(alternative_service_dict);
+  server_pref_dict->SetWithoutPathExpansion("alternative_service",
+                                            alternative_service_list);
 
   // Set the server preference for www.google.com:80.
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   servers_dict->SetWithoutPathExpansion("www.google.com:80", server_pref_dict);
 
   base::DictionaryValue* http_server_properties_dict =
       new base::DictionaryValue;
   HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
   http_server_properties_dict->SetWithoutPathExpansion("servers", servers_dict);
 
   // Set up the pref.
   pref_service_.SetManagedPref(kTestHttpServerProperties,
                                http_server_properties_dict);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
-  // Verify AlternateProtocol is not set.
+  // Verify alternative service is not set.
   EXPECT_FALSE(
       HasAlternativeService(HostPortPair::FromString("www.google.com:80")));
 }
 
 TEST_F(HttpServerPropertiesManagerTest, SupportsSpdy) {
   ExpectPrefsUpdate();
 
   // Post an update task to the network thread. SetSupportsSpdy calls
   // ScheduleUpdatePrefsOnNetworkThread.
 
@@ skipping 229 matching lines @@
       http_server_props_manager_->GetServerNetworkStats(spdy_server_mail);
   EXPECT_EQ(NULL, stats2);
 
   const SettingsMap& settings_map2_ret =
       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
   EXPECT_EQ(0U, settings_map2_ret.size());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 }
 
-// https://crbug.com/444956: Add 200 alternate_protocol servers followed by
+// https://crbug.com/444956: Add 200 alternative_service servers followed by
 // supports_quic and verify we have read supports_quic from prefs.
 TEST_F(HttpServerPropertiesManagerTest, BadSupportsQuic) {
   ExpectCacheUpdate();
 
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
 
   for (int i = 0; i < 200; ++i) {
-    // Set up alternate_protocol for www.google.com:i.
-    base::DictionaryValue* alternate_protocol = new base::DictionaryValue;
-    alternate_protocol->SetInteger("port", i);
-    alternate_protocol->SetString("protocol_str", "npn-spdy/3");
+    // Set up alternative_service for www.google.com:i.
+    base::DictionaryValue* alternative_service_dict = new base::DictionaryValue;
+    alternative_service_dict->SetString("protocol_str", "npn-spdy/3");
+    alternative_service_dict->SetString("host", "");
+    alternative_service_dict->SetInteger("port", i);
+    base::ListValue* alternative_service_list = new base::ListValue;
+    alternative_service_list->Append(alternative_service_dict);
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
-    server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
-                                              alternate_protocol);
+    server_pref_dict->SetWithoutPathExpansion("alternative_service",
+                                              alternative_service_list);
     servers_dict->SetWithoutPathExpansion(StringPrintf("www.google.com:%d", i),
                                           server_pref_dict);
   }
 
   // Set the preference for mail.google.com server.
   base::DictionaryValue* server_pref_dict1 = new base::DictionaryValue;
 
   // Set the server preference for mail.google.com:80.
   servers_dict->SetWithoutPathExpansion("mail.google.com:80",
                                         server_pref_dict1);
@@ skipping 10 matching lines @@
   http_server_properties_dict->SetWithoutPathExpansion("supports_quic",
                                                        supports_quic);
 
   // Set up the pref.
   pref_service_.SetManagedPref(kTestHttpServerProperties,
                                http_server_properties_dict);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
-  // Verify AlternateProtocol.
+  // Verify alternative service.
   for (int i = 0; i < 200; ++i) {
     std::string server = StringPrintf("www.google.com:%d", i);
     AlternativeService alternative_service =
         http_server_props_manager_->GetAlternativeService(
             HostPortPair::FromString(server));
     EXPECT_EQ(i, alternative_service.port);
     EXPECT_EQ(NPN_SPDY_3, alternative_service.protocol);
   }
 
   // Verify SupportsQuic.
   IPAddressNumber address;
   ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
   EXPECT_EQ("127.0.0.1", IPAddressToString(address));
 }
 
 TEST_F(HttpServerPropertiesManagerTest, UpdateCacheWithPrefs) {
   const HostPortPair server_www("www.google.com", 80);
   const HostPortPair server_mail("mail.google.com", 80);
 
   // Set alternate protocol.
-  AlternativeService www_altsvc(NPN_SPDY_3, "www.google.com", 443);
+  AlternativeService www_altsvc(NPN_SPDY_3, "", 443);
   AlternativeService mail_altsvc(NPN_SPDY_3_1, "mail.google.com", 444);
   http_server_props_manager_->SetAlternativeService(server_www, www_altsvc,
                                                     1.0);
   http_server_props_manager_->SetAlternativeService(server_mail, mail_altsvc,
                                                     0.2);
 
   // Set ServerNetworkStats.
   ServerNetworkStats stats;
   stats.srtt = base::TimeDelta::FromInternalValue(42);
   http_server_props_manager_->SetServerNetworkStats(server_mail, stats);
 
   // Set SupportsQuic.
   IPAddressNumber actual_address;
   CHECK(ParseIPLiteralToNumber("127.0.0.1", &actual_address));
   http_server_props_manager_->SetSupportsQuic(true, actual_address);
 
   // Update cache.
   ExpectPrefsUpdate();
   ExpectCacheUpdate();
   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
   base::RunLoop().RunUntilIdle();
 
   // Verify preferences.
-  const char expected_json[] = "{"
-    "\"servers\":{"
-      "\"mail.google.com:80\":{"
-        "\"alternate_protocol\":{"
-          "\"port\":444,\"probability\":0.2,\"protocol_str\":\"npn-spdy/3.1\""
-        "},"
-        "\"network_stats\":{"
-          "\"srtt\":42"
-        "}"
-      "},"
-      "\"www.google.com:80\":{"
-        "\"alternate_protocol\":{"
-          "\"port\":443,\"probability\":1.0,\"protocol_str\":\"npn-spdy/3\""
-        "}"
-      "}"
-    "},"
-    "\"supports_quic\":{"
-      "\"address\":\"127.0.0.1\",\"used_quic\":true"
-    "},"
-    "\"version\":3"
-  "}";
+  const char expected_json[] =
+      "{\"servers\":{\"mail.google.com:80\":{\"alternative_service\":[{"
+      "\"host\":"
+      "\"mail.google.com\",\"port\":444,\"probability\":0.2,\"protocol_str\":"
+      "\"npn-spdy/"
+      "3.1\"}],\"network_stats\":{\"srtt\":42}},\"www.google.com:80\":"
+      "{\"alternative_service\":[{\"port\":443,\"probability\":1.0,"
+      "\"protocol_str\":\"npn-spdy/3\"}]}},\"supports_quic\":"
+      "{\"address\":\"127.0.0.1\",\"used_quic\":true},\"version\":3}";
 
   const base::Value* http_server_properties =
       pref_service_.GetUserPref(kTestHttpServerProperties);
   ASSERT_NE(nullptr, http_server_properties);
   std::string preferences_json;
   EXPECT_TRUE(
       base::JSONWriter::Write(http_server_properties, &preferences_json));
   EXPECT_EQ(expected_json, preferences_json);
 }
 
@@ skipping 65 matching lines @@
   // Run the task after shutdown, but before deletion.
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net