Change AlternativeServiceInfo to a class

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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 396 matching lines @@
 
   // Verify alternative service.
   if (GetParam() >= 4) {
     const AlternativeServiceMap& map =
         http_server_props_manager_->alternative_service_map();
     ASSERT_EQ(2u, map.size());
 
     AlternativeServiceMap::const_iterator map_it = map.begin();
     EXPECT_EQ("mail.google.com", map_it->first.host());
     ASSERT_EQ(1u, map_it->second.size());
-    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service.protocol);
-    EXPECT_TRUE(map_it->second[0].alternative_service.host.empty());
-    EXPECT_EQ(444, map_it->second[0].alternative_service.port);
+    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service().protocol);
+    EXPECT_TRUE(map_it->second[0].alternative_service().host.empty());
+    EXPECT_EQ(444, map_it->second[0].alternative_service().port);
     ++map_it;
     EXPECT_EQ("www.google.com", map_it->first.host());
     ASSERT_EQ(2u, map_it->second.size());
-    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service.protocol);
-    EXPECT_TRUE(map_it->second[0].alternative_service.host.empty());
-    EXPECT_EQ(443, map_it->second[0].alternative_service.port);
-    EXPECT_EQ(kProtoQUIC, map_it->second[1].alternative_service.protocol);
-    EXPECT_TRUE(map_it->second[1].alternative_service.host.empty());
-    EXPECT_EQ(1234, map_it->second[1].alternative_service.port);
+    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service().protocol);
+    EXPECT_TRUE(map_it->second[0].alternative_service().host.empty());
+    EXPECT_EQ(443, map_it->second[0].alternative_service().port);
+    EXPECT_EQ(kProtoQUIC, map_it->second[1].alternative_service().protocol);
+    EXPECT_TRUE(map_it->second[1].alternative_service().host.empty());
+    EXPECT_EQ(1234, map_it->second[1].alternative_service().port);
   } else {
     const AlternativeServiceMap& map =
         http_server_props_manager_->alternative_service_map();
     ASSERT_EQ(2u, map.size());
     AlternativeServiceMap::const_iterator map_it = map.begin();
     EXPECT_EQ("www.google.com", map_it->first.host());
     ASSERT_EQ(2u, map_it->second.size());
-    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service.protocol);
-    EXPECT_TRUE(map_it->second[0].alternative_service.host.empty());
-    EXPECT_EQ(443, map_it->second[0].alternative_service.port);
-    EXPECT_EQ(kProtoQUIC, map_it->second[1].alternative_service.protocol);
-    EXPECT_TRUE(map_it->second[1].alternative_service.host.empty());
-    EXPECT_EQ(1234, map_it->second[1].alternative_service.port);
+    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service().protocol);
+    EXPECT_TRUE(map_it->second[0].alternative_service().host.empty());
+    EXPECT_EQ(443, map_it->second[0].alternative_service().port);
+    EXPECT_EQ(kProtoQUIC, map_it->second[1].alternative_service().protocol);
+    EXPECT_TRUE(map_it->second[1].alternative_service().host.empty());
+    EXPECT_EQ(1234, map_it->second[1].alternative_service().port);
     ++map_it;
     EXPECT_EQ("mail.google.com", map_it->first.host());
     ASSERT_EQ(1u, map_it->second.size());
-    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service.protocol);
-    EXPECT_TRUE(map_it->second[0].alternative_service.host.empty());
-    EXPECT_EQ(444, map_it->second[0].alternative_service.port);
+    EXPECT_EQ(kProtoHTTP2, map_it->second[0].alternative_service().protocol);
+    EXPECT_TRUE(map_it->second[0].alternative_service().host.empty());
+    EXPECT_EQ(444, map_it->second[0].alternative_service().port);
   }
 
   // Verify SupportsQuic.
   IPAddress last_address;
   EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&last_address));
   EXPECT_EQ("127.0.0.1", last_address.ToString());
 
   // Verify ServerNetworkStats.
   const ServerNetworkStats* stats2 =
       http_server_props_manager_->GetServerNetworkStats(google_server);
@@ skipping 284 matching lines @@
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   AlternativeServiceInfoVector alternative_service_info_vector =
       http_server_props_manager_->GetAlternativeServiceInfos(spdy_server_mail);
   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());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SetAlternativeServices) {
   ExpectPrefsUpdate(1);
   ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   AlternativeServiceInfoVector alternative_service_info_vector;
   const AlternativeService alternative_service1(kProtoHTTP2, "mail.google.com",
@@ skipping 18 matching lines @@
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   AlternativeServiceInfoVector alternative_service_info_vector2 =
       http_server_props_manager_->GetAlternativeServiceInfos(spdy_server_mail);
   ASSERT_EQ(2u, alternative_service_info_vector2.size());
   EXPECT_EQ(alternative_service1,
-            alternative_service_info_vector2[0].alternative_service);
+            alternative_service_info_vector2[0].alternative_service());
   EXPECT_EQ(alternative_service2,
-            alternative_service_info_vector2[1].alternative_service);
+            alternative_service_info_vector2[1].alternative_service());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SetAlternativeServicesEmpty) {
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com",
                                                443);
   http_server_props_manager_->SetAlternativeServices(
       spdy_server_mail, AlternativeServiceInfoVector());
 
@@ skipping 334 matching lines @@
     GURL server_gurl;
     if (GetParam() >= 5) {
       server_gurl = GURL(StringPrintf("https://www.google.com:%d", i));
     } else {
       server_gurl = GURL(StringPrintf("https://www.google.com:%d", i));
     }
     url::SchemeHostPort server(server_gurl);
     AlternativeServiceInfoVector alternative_service_info_vector =
         http_server_props_manager_->GetAlternativeServiceInfos(server);
     ASSERT_EQ(1u, alternative_service_info_vector.size());
-    EXPECT_EQ(kProtoQUIC,
-              alternative_service_info_vector[0].alternative_service.protocol);
-    EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service.port);
+    EXPECT_EQ(
+        kProtoQUIC,
+        alternative_service_info_vector[0].alternative_service().protocol);
+    EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service().port);
   }
 
   // Verify SupportsQuic.
   IPAddress address;
   ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
   EXPECT_EQ("127.0.0.1", address.ToString());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, UpdatePrefsWithCache) {
   ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5);
@@ skipping 126 matching lines @@
   AlternativeServiceMap alternative_service_map(/*max_size=*/5);
   EXPECT_TRUE(http_server_props_manager_->AddToAlternativeServiceMap(
       server, *server_dict, &alternative_service_map));
 
   AlternativeServiceMap::iterator it = alternative_service_map.Get(server);
   ASSERT_NE(alternative_service_map.end(), it);
   AlternativeServiceInfoVector alternative_service_info_vector = it->second;
   ASSERT_EQ(3u, alternative_service_info_vector.size());
 
   EXPECT_EQ(kProtoHTTP2,
-            alternative_service_info_vector[0].alternative_service.protocol);
-  EXPECT_EQ("", alternative_service_info_vector[0].alternative_service.host);
-  EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service.port);
+            alternative_service_info_vector[0].alternative_service().protocol);
+  EXPECT_EQ("", alternative_service_info_vector[0].alternative_service().host);
+  EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service().port);
   // Expiration defaults to one day from now, testing with tolerance.
   const base::Time now = base::Time::Now();
-  const base::Time expiration = alternative_service_info_vector[0].expiration;
+  const base::Time expiration = alternative_service_info_vector[0].expiration();
   EXPECT_LE(now + base::TimeDelta::FromHours(23), expiration);
   EXPECT_GE(now + base::TimeDelta::FromDays(1), expiration);
 
   EXPECT_EQ(kProtoQUIC,
-            alternative_service_info_vector[1].alternative_service.protocol);
-  EXPECT_EQ("", alternative_service_info_vector[1].alternative_service.host);
-  EXPECT_EQ(123, alternative_service_info_vector[1].alternative_service.port);
+            alternative_service_info_vector[1].alternative_service().protocol);
+  EXPECT_EQ("", alternative_service_info_vector[1].alternative_service().host);
+  EXPECT_EQ(123, alternative_service_info_vector[1].alternative_service().port);
   // numeric_limits<int64_t>::max() represents base::Time::Max().
-  EXPECT_EQ(base::Time::Max(), alternative_service_info_vector[1].expiration);
+  EXPECT_EQ(base::Time::Max(), alternative_service_info_vector[1].expiration());
 
   EXPECT_EQ(kProtoHTTP2,
-            alternative_service_info_vector[2].alternative_service.protocol);
+            alternative_service_info_vector[2].alternative_service().protocol);
   EXPECT_EQ("example.org",
-            alternative_service_info_vector[2].alternative_service.host);
-  EXPECT_EQ(1234, alternative_service_info_vector[2].alternative_service.port);
+            alternative_service_info_vector[2].alternative_service().host);
+  EXPECT_EQ(1234,
+            alternative_service_info_vector[2].alternative_service().port);
   base::Time expected_expiration;
   ASSERT_TRUE(
       base::Time::FromUTCString("2036-12-31 10:00:00", &expected_expiration));
-  EXPECT_EQ(expected_expiration, alternative_service_info_vector[2].expiration);
+  EXPECT_EQ(expected_expiration,
+            alternative_service_info_vector[2].expiration());
 }
 
 // Regression test for https://crbug.com/615497.
 TEST_P(HttpServerPropertiesManagerTest, DoNotLoadAltSvcForInsecureOrigins) {
   std::unique_ptr<base::Value> server_value = base::JSONReader::Read(
       "{\"alternative_service\":[{\"port\":443,\"protocol_str\":\"h2\","
       "\"expiration\":\"9223372036854775807\"}]}");
   ASSERT_TRUE(server_value);
   base::DictionaryValue* server_dict;
   ASSERT_TRUE(server_value->GetAsDictionary(&server_dict));
@@ skipping 120 matching lines @@
   AlternativeServiceMap alternative_service_map(/*max_size=*/5);
   ASSERT_TRUE(http_server_props_manager_->AddToAlternativeServiceMap(
       server, server_pref_dict, &alternative_service_map));
 
   AlternativeServiceMap::iterator it = alternative_service_map.Get(server);
   ASSERT_NE(alternative_service_map.end(), it);
   AlternativeServiceInfoVector alternative_service_info_vector = it->second;
   ASSERT_EQ(1u, alternative_service_info_vector.size());
 
   EXPECT_EQ(kProtoHTTP2,
-            alternative_service_info_vector[0].alternative_service.protocol);
+            alternative_service_info_vector[0].alternative_service().protocol);
   EXPECT_EQ("valid.example.com",
-            alternative_service_info_vector[0].alternative_service.host);
-  EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service.port);
-  EXPECT_EQ(one_day_from_now_, alternative_service_info_vector[0].expiration);
+            alternative_service_info_vector[0].alternative_service().host);
+  EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service().port);
+  EXPECT_EQ(one_day_from_now_, alternative_service_info_vector[0].expiration());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache0) {
   // Post an update task to the UI thread.
   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
   // Shutdown comes before the task is executed.
   http_server_props_manager_->ShutdownOnPrefSequence();
   http_server_props_manager_.reset();
   // Run the task after shutdown and deletion.
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
@@ skipping 84 matching lines @@
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 }  // namespace net