Change GetAlternativeServies to return alternative service infos.

net/quic/chromium/quic_network_transaction_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 <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 607 matching lines @@
     url::SchemeHostPort server(request_.url);
     AlternativeService alternative_service(kProtoQUIC, alternative.host(),
                                            alternative.port());
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties_.SetAlternativeService(server, alternative_service,
                                                   expiration);
   }
 
   void ExpectBrokenAlternateProtocolMapping() {
     const url::SchemeHostPort server(request_.url);
-    const AlternativeServiceVector alternative_service_vector =
-        http_server_properties_.GetAlternativeServices(server);
-    EXPECT_EQ(1u, alternative_service_vector.size());
+    const AlternativeServiceInfoVector alternative_service_info_vector =
+        http_server_properties_.GetAlternativeServiceInfos(server);
+    EXPECT_EQ(1u, alternative_service_info_vector.size());
     EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
-        alternative_service_vector[0]));
+        alternative_service_info_vector[0].alternative_service));
   }
 
   void ExpectQuicAlternateProtocolMapping() {
     const url::SchemeHostPort server(request_.url);
-    const AlternativeServiceVector alternative_service_vector =
-        http_server_properties_.GetAlternativeServices(server);
-    EXPECT_EQ(1u, alternative_service_vector.size());
-    EXPECT_EQ(kProtoQUIC, alternative_service_vector[0].protocol);
+    const AlternativeServiceInfoVector alternative_service_info_vector =
+        http_server_properties_.GetAlternativeServiceInfos(server);
+    EXPECT_EQ(1u, alternative_service_info_vector.size());
+    EXPECT_EQ(kProtoQUIC,
+              alternative_service_info_vector[0].alternative_service.protocol);
     EXPECT_FALSE(http_server_properties_.IsAlternativeServiceBroken(
-        alternative_service_vector[0]));
+        alternative_service_info_vector[0].alternative_service));
   }
 
   void AddHangingNonAlternateProtocolSocketData() {
     std::unique_ptr<StaticSocketDataProvider> hanging_data;
     hanging_data.reset(new StaticSocketDataProvider());
     MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
     hanging_data->set_connect_data(hanging_connect);
     hanging_data_.push_back(std::move(hanging_data));
     socket_factory_.AddSocketDataProvider(hanging_data_.back().get());
     socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
@@ skipping 635 matching lines @@
   // Send https request, ignore alternative service advertising if response
   // header advertises alternative service for mail.example.org.
   request_.url = GURL("https://mail.example.org:443");
   SendRequestAndExpectHttpResponse("hello world");
   HttpServerProperties* http_server_properties =
       session_->http_server_properties();
   url::SchemeHostPort http_server("http", "mail.example.org", 443);
   url::SchemeHostPort https_server("https", "mail.example.org", 443);
   // Check alternative service is set for the correct origin.
   EXPECT_EQ(
-      2u, http_server_properties->GetAlternativeServices(https_server).size());
+      2u,
+      http_server_properties->GetAlternativeServiceInfos(https_server).size());
   EXPECT_TRUE(
-      http_server_properties->GetAlternativeServices(http_server).empty());
+      http_server_properties->GetAlternativeServiceInfos(http_server).empty());
 }
 
 TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) {
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
                                      0);
 
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   CreateSession();
 
   // Send https request and set alternative services if response header
   // advertises alternative service for mail.example.org.
   SendRequestAndExpectHttpResponse("hello world");
   HttpServerProperties* http_server_properties =
       session_->http_server_properties();
 
   const url::SchemeHostPort https_server(request_.url);
   // Check alternative service is set.
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties->GetAlternativeServices(https_server);
-  EXPECT_EQ(2u, alternative_service_vector.size());
+  EXPECT_EQ(
+      2u,
+      http_server_properties->GetAlternativeServiceInfos(https_server).size());
 
   // Send http request to the same origin but with diffrent scheme, should not
   // use QUIC.
   request_.url = GURL("http://mail.example.org:443");
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) {
   std::string altsvc_header =
       base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_);
@@ skipping 1533 matching lines @@
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
 
   url::SchemeHostPort http_server("https", kDefaultServerHostName, 443);
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties_.GetAlternativeServices(http_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  const AlternativeService alternative_service = alternative_service_vector[0];
-  EXPECT_EQ(kProtoQUIC, alternative_service_vector[0].protocol);
-  EXPECT_EQ(kDefaultServerHostName, alternative_service_vector[0].host);
-  EXPECT_EQ(137, alternative_service_vector[0].port);
+  AlternativeServiceInfoVector alternative_service_info_vector =
+      http_server_properties_.GetAlternativeServiceInfos(http_server);
+  ASSERT_EQ(1u, alternative_service_info_vector.size());
+  const AlternativeService alternative_service =
+      alternative_service_info_vector[0].alternative_service;
+  EXPECT_EQ(kProtoQUIC, alternative_service.protocol);
+  EXPECT_EQ(kDefaultServerHostName, alternative_service.host);
+  EXPECT_EQ(137, alternative_service.port);
 }
 
 TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) {
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
@@ skipping 1784 matching lines @@
 
   request_.url = GURL("https://mail.example.org/pushed.jpg");
   ChunkedUploadDataStream upload_data(0);
   upload_data.AppendData("1", 1, true);
   request_.upload_data_stream = &upload_data;
   SendRequestAndExpectQuicResponse("and hello!");
 }
 
 }  // namespace test
 }  // namespace net