Change AlternativeServiceInfo to a class

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 361 matching lines @@
 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 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);
+            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.
   AlternativeServiceInfo alternative_service_info1(kProtoHTTP2, "foo", 443,
@@ skipping 75 matching lines @@
   // MRU list will be test_server2, test_server1, test_server3.
   impl_.SetAlternativeServiceServers(&alternative_service_map);
 
   // Verify alternative_service_map.
   const AlternativeServiceMap& map = impl_.alternative_service_map();
   ASSERT_EQ(3u, map.size());
   AlternativeServiceMap::const_iterator map_it = map.begin();
 
   EXPECT_TRUE(map_it->first.Equals(test_server2));
   ASSERT_EQ(1u, map_it->second.size());
-  EXPECT_EQ(alternative_service3, map_it->second[0].alternative_service);
-  EXPECT_EQ(expiration3, map_it->second[0].expiration);
+  EXPECT_EQ(alternative_service3, map_it->second[0].alternative_service());
+  EXPECT_EQ(expiration3, map_it->second[0].expiration());
   ++map_it;
   EXPECT_TRUE(map_it->first.Equals(test_server1));
   ASSERT_EQ(1u, map_it->second.size());
-  EXPECT_EQ(alternative_service1, map_it->second[0].alternative_service);
-  EXPECT_EQ(expiration1, map_it->second[0].expiration);
+  EXPECT_EQ(alternative_service1, map_it->second[0].alternative_service());
+  EXPECT_EQ(expiration1, map_it->second[0].expiration());
   ++map_it;
   EXPECT_TRUE(map_it->first.Equals(test_server3));
   ASSERT_EQ(1u, map_it->second.size());
-  EXPECT_EQ(alternative_service4, map_it->second[0].alternative_service);
-  EXPECT_EQ(expiration4, map_it->second[0].expiration);
+  EXPECT_EQ(alternative_service4, map_it->second[0].alternative_service());
+  EXPECT_EQ(expiration4, map_it->second[0].expiration());
 }
 
 // Regression test for https://crbug.com/504032:
 // SetAlternativeServiceServers() should not crash if there is an empty
 // hostname is the mapping.
 TEST_F(AlternateProtocolServerPropertiesTest, SetWithEmptyHostname) {
   url::SchemeHostPort server("https", "foo", 443);
   const AlternativeService alternative_service_with_empty_hostname(kProtoHTTP2,
                                                                    "", 1234);
   const AlternativeService alternative_service_with_foo_hostname(kProtoHTTP2,
                                                                  "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 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_info_vector[0].alternative_service);
+            alternative_service_info_vector[0].alternative_service());
 }
 
 // Regression test for https://crbug.com/516486:
 // 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,
@@ skipping 68 matching lines @@
 
   impl_.SetAlternativeServices(
       canonical_server,
       AlternativeServiceInfoVector(/*size=*/1, alternative_service_info));
 
   // Make sure the canonical service is returned for the other server.
   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);
+            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_.GetAlternativeServiceInfos(server).empty());
 }
 
 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);
+  EXPECT_EQ(alternative_service2, it->second[0].alternative_service());
 
   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);
+            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);
+  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);
   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);
+            alternative_service_info_vector[0].alternative_service());
   EXPECT_FALSE(impl_.IsAlternativeServiceBroken(alternative_service1));
 
   // GetAlternativeServiceInfos should return the broken alternative service.
   impl_.MarkAlternativeServiceBroken(alternative_service1);
   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);
+            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_vector2;
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   alternative_service_info_vector2.push_back(
       AlternativeServiceInfo(alternative_service1, expiration));
   const AlternativeService alternative_service2(kProtoHTTP2, "foo", 1234);
   alternative_service_info_vector2.push_back(
       AlternativeServiceInfo(alternative_service2, expiration));
   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);
+            alternative_service_info_vector[0].alternative_service());
   EXPECT_EQ(alternative_service2,
-            alternative_service_info_vector[1].alternative_service);
+            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_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);
+            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
   // 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);
 
   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);
+            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
   // 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);
   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);
+            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);
+  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_.GetAlternativeServiceInfos(https_server).size());
 
   // Set Alt-Svc list for |https_server|.
   impl_.SetAlternativeServices(https_server, alternative_service_info_vector);
   EXPECT_EQ(2u, impl_.GetAlternativeServiceInfos(https_server).size());
   EXPECT_EQ(2u, impl_.GetAlternativeServiceInfos(http_server).size());
 
@@ skipping 13 matching lines @@
   const AlternativeService alternative_service2(kProtoHTTP2, "bar", 1234);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service2, expiration));
   url::SchemeHostPort test_server("http", "foo", 80);
   impl_.SetAlternativeServices(test_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(test_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);
+  EXPECT_EQ(alternative_service1, it->second[0].alternative_service());
+  EXPECT_EQ(alternative_service2, it->second[1].alternative_service());
 
   impl_.SetAlternativeServices(test_server, AlternativeServiceInfoVector());
   EXPECT_TRUE(map.empty());
 }
 
 // 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);
   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);
+            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_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);
+            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 38 matching lines @@
       AlternativeServiceInfo(canonical_alternative_service2, expiration));
   impl_.SetAlternativeServices(canonical_server,
                                alternative_service_info_vector);
 
   // Since |test_server| does not have an alternative service itself,
   // 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);
+            alternative_service_info_vector2[0].alternative_service());
 
   // Since |canonical_alternative_service2| has an empty host,
   // GetAlternativeServiceInfos should substitute the hostname of its |origin|
   // argument.
   EXPECT_EQ(test_server.host(),
-            alternative_service_info_vector2[1].alternative_service.host);
+            alternative_service_info_vector2[1].alternative_service().host);
   EXPECT_EQ(canonical_alternative_service2.protocol,
-            alternative_service_info_vector2[1].alternative_service.protocol);
+            alternative_service_info_vector2[1].alternative_service().protocol);
   EXPECT_EQ(canonical_alternative_service2.port,
-            alternative_service_info_vector2[1].alternative_service.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 21 matching lines @@
 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);
   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);
+            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_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);
+            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 365 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