Change GetAlternativeServies to return alternative service infos.

net/http/http_server_properties_impl_unittest.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 <memory>
 #include <string>
 #include <vector>
 
@@ skipping 33 matching lines @@
   }
 };
 
 namespace {
 
 const int kMaxSupportsSpdyServerHosts = 500;
 
 class HttpServerPropertiesImplTest : public testing::Test {
  protected:
   bool HasAlternativeService(const url::SchemeHostPort& origin) {
-    const AlternativeServiceVector alternative_service_vector =
-        impl_.GetAlternativeServices(origin);
-    return !alternative_service_vector.empty();
+    const AlternativeServiceInfoVector alternative_service_info_vector =
+        impl_.GetAlternativeServiceInfos(origin);
+    return !alternative_service_info_vector.empty();
   }
 
   bool SetAlternativeService(const url::SchemeHostPort& origin,
                              const AlternativeService& alternative_service) {
     const base::Time expiration =
         base::Time::Now() + base::TimeDelta::FromDays(1);
     return impl_.SetAlternativeService(origin, alternative_service, expiration);
   }
 
   HttpServerPropertiesImpl impl_;
@@ skipping 276 matching lines @@
 }
 
 typedef HttpServerPropertiesImplTest AlternateProtocolServerPropertiesTest;
 
 TEST_F(AlternateProtocolServerPropertiesTest, Basic) {
   url::SchemeHostPort test_server("http", "foo", 80);
   EXPECT_FALSE(HasAlternativeService(test_server));
 
   AlternativeService alternative_service(kProtoHTTP2, "foo", 443);
   SetAlternativeService(test_server, alternative_service);
-  const AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service, alternative_service_vector[0]);
+  const AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(alternative_service,
+            alternative_service_info_vector[0].alternative_service);
 
   impl_.Clear();
   EXPECT_FALSE(HasAlternativeService(test_server));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ExcludeOrigin) {
   AlternativeServiceInfoVector alternative_service_info_vector;
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   // Same hostname, same port, TCP: should be ignored.
-  AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(alternative_service1, expiration));
-  // Different hostname: GetAlternativeServices should return this one.
-  AlternativeService alternative_service2(kProtoHTTP2, "bar", 443);
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(alternative_service2, expiration));
-  // Different port: GetAlternativeServices should return this one too.
-  AlternativeService alternative_service3(kProtoHTTP2, "foo", 80);
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(alternative_service3, expiration));
+  AlternativeServiceInfo alternative_service_info1(kProtoHTTP2, "foo", 443,
+                                                   expiration);
+  alternative_service_info_vector.push_back(alternative_service_info1);
+  // Different hostname: GetAlternativeServiceInfos should return this one.
+  AlternativeServiceInfo alternative_service_info2(kProtoHTTP2, "bar", 443,
+                                                   expiration);
+  alternative_service_info_vector.push_back(alternative_service_info2);
+  // Different port: GetAlternativeServiceInfos should return this one too.
+  AlternativeServiceInfo alternative_service_info3(kProtoHTTP2, "foo", 80,
+                                                   expiration);
+  alternative_service_info_vector.push_back(alternative_service_info3);
   // QUIC: GetAlternativeServices should return this one too.
-  AlternativeService alternative_service4(kProtoQUIC, "foo", 443);
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(alternative_service4, expiration));
+  AlternativeServiceInfo alternative_service_info4(kProtoQUIC, "foo", 443,
+                                                   expiration);
+  alternative_service_info_vector.push_back(alternative_service_info4);
 
   url::SchemeHostPort test_server("https", "foo", 443);
   impl_.SetAlternativeServices(test_server, alternative_service_info_vector);
 
-  const AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(3u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service2, alternative_service_vector[0]);
-  EXPECT_EQ(alternative_service3, alternative_service_vector[1]);
-  EXPECT_EQ(alternative_service4, alternative_service_vector[2]);
+  const AlternativeServiceInfoVector alternative_service_info_vector2 =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(3u, alternative_service_info_vector2.size());
+  EXPECT_EQ(alternative_service_info2, alternative_service_info_vector2[0]);
+  EXPECT_EQ(alternative_service_info3, alternative_service_info_vector2[1]);
+  EXPECT_EQ(alternative_service_info4, alternative_service_info_vector2[2]);
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, Set) {
   // |test_server1| has an alternative service, which will not be
   // affected by SetAlternativeServiceServers(), because
   // |alternative_service_map| does not have an entry for
   // |test_server1|.
   url::SchemeHostPort test_server1("http", "foo1", 80);
   const AlternativeService alternative_service1(kProtoHTTP2, "bar1", 443);
   const base::Time now = base::Time::Now();
@@ skipping 73 matching lines @@
                                                                  "foo", 1234);
   SetAlternativeService(server, alternative_service_with_empty_hostname);
   impl_.MarkAlternativeServiceBroken(alternative_service_with_foo_hostname);
 
   AlternativeServiceMap alternative_service_map(
       AlternativeServiceMap::NO_AUTO_EVICT);
   impl_.SetAlternativeServiceServers(&alternative_service_map);
 
   EXPECT_TRUE(
       impl_.IsAlternativeServiceBroken(alternative_service_with_foo_hostname));
-  const AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
+  const AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
   EXPECT_EQ(alternative_service_with_foo_hostname,
-            alternative_service_vector[0]);
+            alternative_service_info_vector[0].alternative_service);
 }
 
 // Regression test for https://crbug.com/516486:
-// GetAlternativeServices() should remove |alternative_service_map_| elements
-// with empty value.
+// GetAlternativeServiceInfos() should remove |alternative_service_map_|
+// elements with empty value.
 TEST_F(AlternateProtocolServerPropertiesTest, EmptyVector) {
   url::SchemeHostPort server("https", "foo", 443);
   const AlternativeService alternative_service(kProtoHTTP2, "bar", 443);
   base::Time expiration = base::Time::Now() - base::TimeDelta::FromDays(1);
   const AlternativeServiceInfo alternative_service_info(alternative_service,
                                                         expiration);
   AlternativeServiceMap alternative_service_map(
       AlternativeServiceMap::NO_AUTO_EVICT);
   alternative_service_map.Put(
       server,
       AlternativeServiceInfoVector(/*size=*/1, alternative_service_info));
 
   // Prepare |alternative_service_map_| with a single key that has a single
   // AlternativeServiceInfo with identical hostname and port.
   impl_.SetAlternativeServiceServers(&alternative_service_map);
 
-  // GetAlternativeServices() should remove such AlternativeServiceInfo from
+  // GetAlternativeServiceInfos() should remove such AlternativeServiceInfo from
   // |alternative_service_map_|, emptying the AlternativeServiceInfoVector
   // corresponding to |server|.
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(server);
-  ASSERT_TRUE(alternative_service_vector.empty());
+  ASSERT_TRUE(impl_.GetAlternativeServiceInfos(server).empty());
 
-  // GetAlternativeServices() should remove this key from
+  // GetAlternativeServiceInfos() should remove this key from
   // |alternative_service_map_|, and SetAlternativeServices() should not crash.
   impl_.SetAlternativeServices(
       server,
       AlternativeServiceInfoVector(/*size=*/1, alternative_service_info));
 
   // There should still be no alternative service assigned to |server|.
-  alternative_service_vector = impl_.GetAlternativeServices(server);
-  ASSERT_TRUE(alternative_service_vector.empty());
+  ASSERT_TRUE(impl_.GetAlternativeServiceInfos(server).empty());
 }
 
 // Regression test for https://crbug.com/516486 for the canonical host case.
 TEST_F(AlternateProtocolServerPropertiesTest, EmptyVectorForCanonical) {
   url::SchemeHostPort server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   const AlternativeService alternative_service(kProtoHTTP2, "", 443);
   base::Time expiration = base::Time::Now() - base::TimeDelta::FromDays(1);
   const AlternativeServiceInfo alternative_service_info(alternative_service,
                                                         expiration);
   AlternativeServiceMap alternative_service_map(
       AlternativeServiceMap::NO_AUTO_EVICT);
   alternative_service_map.Put(
       canonical_server,
       AlternativeServiceInfoVector(/*size=*/1, alternative_service_info));
 
   // Prepare |alternative_service_map_| with a single key that has a single
   // AlternativeServiceInfo with identical hostname and port.
   impl_.SetAlternativeServiceServers(&alternative_service_map);
 
-  // GetAlternativeServices() should remove such AlternativeServiceInfo from
+  // GetAlternativeServiceInfos() should remove such AlternativeServiceInfo from
   // |alternative_service_map_|, emptying the AlternativeServiceInfoVector
   // corresponding to |canonical_server|, even when looking up
   // alternative services for |server|.
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(server);
-  ASSERT_TRUE(alternative_service_vector.empty());
+  ASSERT_TRUE(impl_.GetAlternativeServiceInfos(server).empty());
 
-  // GetAlternativeServices() should remove this key from
+  // GetAlternativeServiceInfos() should remove this key from
   // |alternative_service_map_|, and SetAlternativeServices() should not crash.
   impl_.SetAlternativeServices(
       canonical_server,
       AlternativeServiceInfoVector(/*size=*/1, alternative_service_info));
 
   // There should still be no alternative service assigned to
   // |canonical_server|.
-  alternative_service_vector = impl_.GetAlternativeServices(canonical_server);
-  ASSERT_TRUE(alternative_service_vector.empty());
+  ASSERT_TRUE(impl_.GetAlternativeServiceInfos(canonical_server).empty());
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearServerWithCanonical) {
   url::SchemeHostPort server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   const AlternativeService alternative_service(kProtoQUIC, "", 443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   const AlternativeServiceInfo alternative_service_info(alternative_service,
                                                         expiration);
 
   impl_.SetAlternativeServices(
       canonical_server,
       AlternativeServiceInfoVector(/*size=*/1, alternative_service_info));
 
   // Make sure the canonical service is returned for the other server.
-  const AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(kProtoQUIC, alternative_service_vector[0].protocol);
-  EXPECT_EQ(443, alternative_service_vector[0].port);
+  const AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(kProtoQUIC,
+            alternative_service_info_vector[0].alternative_service.protocol);
+  EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service.port);
 
   // Now clear the alternatives for the other server and make sure it stays
   // cleared.
   // GetAlternativeServices() should remove this key from
   // |alternative_service_map_|, and SetAlternativeServices() should not crash.
   impl_.SetAlternativeServices(server, AlternativeServiceInfoVector());
 
-  ASSERT_TRUE(impl_.GetAlternativeServices(server).empty());
+  ASSERT_TRUE(impl_.GetAlternativeServiceInfos(server).empty());
 }
 
-TEST_F(AlternateProtocolServerPropertiesTest, MRUOfGetAlternativeServices) {
+TEST_F(AlternateProtocolServerPropertiesTest, MRUOfGetAlternativeServiceInfos) {
   url::SchemeHostPort test_server1("http", "foo1", 80);
   const AlternativeService alternative_service1(kProtoHTTP2, "foo1", 443);
   SetAlternativeService(test_server1, alternative_service1);
   url::SchemeHostPort test_server2("http", "foo2", 80);
   const AlternativeService alternative_service2(kProtoHTTP2, "foo2", 1234);
   SetAlternativeService(test_server2, alternative_service2);
 
   const AlternativeServiceMap& map = impl_.alternative_service_map();
   AlternativeServiceMap::const_iterator it = map.begin();
   EXPECT_TRUE(it->first.Equals(test_server2));
   ASSERT_EQ(1u, it->second.size());
   EXPECT_EQ(alternative_service2, it->second[0].alternative_service);
 
-  const AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server1);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service1, alternative_service_vector[0]);
+  const AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server1);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(alternative_service1,
+            alternative_service_info_vector[0].alternative_service);
 
   // GetAlternativeServices should reorder the AlternateProtocol map.
   it = map.begin();
   EXPECT_TRUE(it->first.Equals(test_server1));
   ASSERT_EQ(1u, it->second.size());
   EXPECT_EQ(alternative_service1, it->second[0].alternative_service);
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, SetBroken) {
   url::SchemeHostPort test_server("http", "foo", 80);
   const AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
   SetAlternativeService(test_server, alternative_service1);
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service1, alternative_service_vector[0]);
+  AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(alternative_service1,
+            alternative_service_info_vector[0].alternative_service);
   EXPECT_FALSE(impl_.IsAlternativeServiceBroken(alternative_service1));
 
-  // GetAlternativeServices should return the broken alternative service.
+  // GetAlternativeServiceInfos should return the broken alternative service.
   impl_.MarkAlternativeServiceBroken(alternative_service1);
-  alternative_service_vector = impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service1, alternative_service_vector[0]);
+  alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(alternative_service1,
+            alternative_service_info_vector[0].alternative_service);
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service1));
 
   // SetAlternativeServices should add a broken alternative service to the map.
-  AlternativeServiceInfoVector alternative_service_info_vector;
+  AlternativeServiceInfoVector alternative_service_info_vector2;
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  alternative_service_info_vector.push_back(
+  alternative_service_info_vector2.push_back(
       AlternativeServiceInfo(alternative_service1, expiration));
   const AlternativeService alternative_service2(kProtoHTTP2, "foo", 1234);
-  alternative_service_info_vector.push_back(
+  alternative_service_info_vector2.push_back(
       AlternativeServiceInfo(alternative_service2, expiration));
-  impl_.SetAlternativeServices(test_server, alternative_service_info_vector);
-  alternative_service_vector = impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(2u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service1, alternative_service_vector[0]);
-  EXPECT_EQ(alternative_service2, alternative_service_vector[1]);
-  EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service_vector[0]));
-  EXPECT_FALSE(impl_.IsAlternativeServiceBroken(alternative_service_vector[1]));
+  impl_.SetAlternativeServices(test_server, alternative_service_info_vector2);
+  alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(2u, alternative_service_info_vector.size());
+  EXPECT_EQ(alternative_service1,
+            alternative_service_info_vector[0].alternative_service);
+  EXPECT_EQ(alternative_service2,
+            alternative_service_info_vector[1].alternative_service);
+  EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(impl_.IsAlternativeServiceBroken(alternative_service2));
 
   // SetAlternativeService should add a broken alternative service to the map.
   SetAlternativeService(test_server, alternative_service1);
-  alternative_service_vector = impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service1, alternative_service_vector[0]);
-  EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service_vector[0]));
+  alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(alternative_service1,
+            alternative_service_info_vector[0].alternative_service);
+  EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service1));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, MaxAge) {
   AlternativeServiceInfoVector alternative_service_info_vector;
   base::Time now = base::Time::Now();
   base::TimeDelta one_day = base::TimeDelta::FromDays(1);
 
   // First alternative service expired one day ago, should not be returned by
-  // GetAlternativeServices().
+  // GetAlternativeServiceInfos().
   const AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, now - one_day));
 
   // Second alterrnative service will expire one day from now, should be
   // returned by GetAlternativeSerices().
   const AlternativeService alternative_service2(kProtoHTTP2, "bar", 1234);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service2, now + one_day));
 
   url::SchemeHostPort test_server("http", "foo", 80);
   impl_.SetAlternativeServices(test_server, alternative_service_info_vector);
 
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service2, alternative_service_vector[0]);
+  AlternativeServiceInfoVector alternative_service_info_vector2 =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector2.size());
+  EXPECT_EQ(alternative_service2,
+            alternative_service_info_vector2[0].alternative_service);
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, MaxAgeCanonical) {
   AlternativeServiceInfoVector alternative_service_info_vector;
   base::Time now = base::Time::Now();
   base::TimeDelta one_day = base::TimeDelta::FromDays(1);
 
   // First alternative service expired one day ago, should not be returned by
-  // GetAlternativeServices().
+  // GetAlternativeServiceInfos().
   const AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, now - one_day));
 
   // Second alterrnative service will expire one day from now, should be
   // returned by GetAlternativeSerices().
   const AlternativeService alternative_service2(kProtoHTTP2, "bar", 1234);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service2, now + one_day));
 
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   impl_.SetAlternativeServices(canonical_server,
                                alternative_service_info_vector);
 
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(alternative_service2, alternative_service_vector[0]);
+  AlternativeServiceInfoVector alternative_service_info_vector2 =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector2.size());
+  EXPECT_EQ(alternative_service2,
+            alternative_service_info_vector2[0].alternative_service);
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, AlternativeServiceWithScheme) {
   AlternativeServiceInfoVector alternative_service_info_vector;
   const AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, expiration));
   const AlternativeService alternative_service2(kProtoHTTP2, "bar", 1234);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service2, expiration));
   // Set Alt-Svc list for |http_server|.
   url::SchemeHostPort http_server("http", "foo", 80);
   impl_.SetAlternativeServices(http_server, alternative_service_info_vector);
 
   const net::AlternativeServiceMap& map = impl_.alternative_service_map();
   net::AlternativeServiceMap::const_iterator it = map.begin();
   EXPECT_TRUE(it->first.Equals(http_server));
   ASSERT_EQ(2u, it->second.size());
   EXPECT_EQ(alternative_service1, it->second[0].alternative_service);
   EXPECT_EQ(alternative_service2, it->second[1].alternative_service);
 
   // Check Alt-Svc list should not be set for |https_server|.
   url::SchemeHostPort https_server("https", "foo", 80);
-  EXPECT_EQ(0u, impl_.GetAlternativeServices(https_server).size());
+  EXPECT_EQ(0u, impl_.GetAlternativeServiceInfos(https_server).size());
 
   // Set Alt-Svc list for |https_server|.
   impl_.SetAlternativeServices(https_server, alternative_service_info_vector);
-  EXPECT_EQ(2u, impl_.GetAlternativeServices(https_server).size());
-  EXPECT_EQ(2u, impl_.GetAlternativeServices(http_server).size());
+  EXPECT_EQ(2u, impl_.GetAlternativeServiceInfos(https_server).size());
+  EXPECT_EQ(2u, impl_.GetAlternativeServiceInfos(http_server).size());
 
   // Clear Alt-Svc list for |http_server|.
   impl_.SetAlternativeServices(http_server, AlternativeServiceInfoVector());
 
-  EXPECT_EQ(0u, impl_.GetAlternativeServices(http_server).size());
-  EXPECT_EQ(2u, impl_.GetAlternativeServices(https_server).size());
+  EXPECT_EQ(0u, impl_.GetAlternativeServiceInfos(http_server).size());
+  EXPECT_EQ(2u, impl_.GetAlternativeServiceInfos(https_server).size());
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearAlternativeServices) {
   AlternativeServiceInfoVector alternative_service_info_vector;
   const AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, expiration));
   const AlternativeService alternative_service2(kProtoHTTP2, "bar", 1234);
   alternative_service_info_vector.push_back(
@@ skipping 15 matching lines @@
 // A broken alternative service in the mapping carries meaningful information,
 // therefore it should not be ignored by SetAlternativeService().  In
 // particular, an alternative service mapped to an origin shadows alternative
 // services of canonical hosts.
 TEST_F(AlternateProtocolServerPropertiesTest, BrokenShadowsCanonical) {
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   AlternativeService canonical_alternative_service(kProtoQUIC,
                                                    "bar.c.youtube.com", 1234);
   SetAlternativeService(canonical_server, canonical_alternative_service);
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(canonical_alternative_service, alternative_service_vector[0]);
+  AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(canonical_alternative_service,
+            alternative_service_info_vector[0].alternative_service);
 
   const AlternativeService broken_alternative_service(kProtoHTTP2, "foo", 443);
   impl_.MarkAlternativeServiceBroken(broken_alternative_service);
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(broken_alternative_service));
 
   SetAlternativeService(test_server, broken_alternative_service);
-  alternative_service_vector = impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(broken_alternative_service, alternative_service_vector[0]);
+  alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(broken_alternative_service,
+            alternative_service_info_vector[0].alternative_service);
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(broken_alternative_service));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearBroken) {
   url::SchemeHostPort test_server("http", "foo", 80);
   const AlternativeService alternative_service(kProtoHTTP2, "foo", 443);
   SetAlternativeService(test_server, alternative_service);
   impl_.MarkAlternativeServiceBroken(alternative_service);
   ASSERT_TRUE(HasAlternativeService(test_server));
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service));
@@ skipping 33 matching lines @@
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(canonical_alternative_service1, expiration));
   const AlternativeService canonical_alternative_service2(kProtoHTTP2, "", 443);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(canonical_alternative_service2, expiration));
   impl_.SetAlternativeServices(canonical_server,
                                alternative_service_info_vector);
 
   // Since |test_server| does not have an alternative service itself,
-  // GetAlternativeServices should return those of |canonical_server|.
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(test_server);
-  ASSERT_EQ(2u, alternative_service_vector.size());
-  EXPECT_EQ(canonical_alternative_service1, alternative_service_vector[0]);
+  // GetAlternativeServiceInfos should return those of |canonical_server|.
+  AlternativeServiceInfoVector alternative_service_info_vector2 =
+      impl_.GetAlternativeServiceInfos(test_server);
+  ASSERT_EQ(2u, alternative_service_info_vector2.size());
+  EXPECT_EQ(canonical_alternative_service1,
+            alternative_service_info_vector2[0].alternative_service);
 
   // Since |canonical_alternative_service2| has an empty host,
-  // GetAlternativeServices should substitute the hostname of its |origin|
+  // GetAlternativeServiceInfos should substitute the hostname of its |origin|
   // argument.
-  EXPECT_EQ(test_server.host(), alternative_service_vector[1].host);
+  EXPECT_EQ(test_server.host(),
+            alternative_service_info_vector2[1].alternative_service.host);
   EXPECT_EQ(canonical_alternative_service2.protocol,
-            alternative_service_vector[1].protocol);
+            alternative_service_info_vector2[1].alternative_service.protocol);
   EXPECT_EQ(canonical_alternative_service2.port,
-            alternative_service_vector[1].port);
+            alternative_service_info_vector2[1].alternative_service.port);
 
   // Verify the canonical suffix.
   EXPECT_EQ(".c.youtube.com", *impl_.GetCanonicalSuffix(test_server.host()));
   EXPECT_EQ(".c.youtube.com",
             *impl_.GetCanonicalSuffix(canonical_server.host()));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearCanonical) {
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
@@ skipping 17 matching lines @@
   EXPECT_FALSE(HasAlternativeService(test_server));
 }
 
 // Adding an alternative service for a new host overrides canonical host.
 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalOverride) {
   url::SchemeHostPort foo_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort bar_server("https", "bar.c.youtube.com", 443);
   AlternativeService bar_alternative_service(kProtoQUIC, "bar.c.youtube.com",
                                              1234);
   SetAlternativeService(bar_server, bar_alternative_service);
-  AlternativeServiceVector alternative_service_vector =
-      impl_.GetAlternativeServices(foo_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(bar_alternative_service, alternative_service_vector[0]);
+  AlternativeServiceInfoVector alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(foo_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(bar_alternative_service,
+            alternative_service_info_vector[0].alternative_service);
 
   url::SchemeHostPort qux_server("https", "qux.c.youtube.com", 443);
   AlternativeService qux_alternative_service(kProtoQUIC, "qux.c.youtube.com",
                                              443);
   SetAlternativeService(qux_server, qux_alternative_service);
-  alternative_service_vector = impl_.GetAlternativeServices(foo_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(qux_alternative_service, alternative_service_vector[0]);
+  alternative_service_info_vector =
+      impl_.GetAlternativeServiceInfos(foo_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  EXPECT_EQ(qux_alternative_service,
+            alternative_service_info_vector[0].alternative_service);
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearWithCanonical) {
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   AlternativeService canonical_alternative_service(kProtoQUIC,
                                                    "bar.c.youtube.com", 1234);
 
   SetAlternativeService(canonical_server, canonical_alternative_service);
   impl_.Clear();
@@ skipping 301 matching lines @@
   EXPECT_EQ(quic_server_info1, *(impl_.GetQuicServerInfo(quic_server_id)));
 
   impl_.Clear();
   EXPECT_EQ(0u, impl_.quic_server_info_map().size());
   EXPECT_EQ(nullptr, impl_.GetQuicServerInfo(quic_server_id));
 }
 
 }  // namespace
 
 }  // namespace net