OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_server_properties_manager.h" | 5 #include "net/http/http_server_properties_manager.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
76 base::Closure prefs_changed_callback_; | 76 base::Closure prefs_changed_callback_; |
77 | 77 |
78 DISALLOW_COPY_AND_ASSIGN(MockPrefDelegate); | 78 DISALLOW_COPY_AND_ASSIGN(MockPrefDelegate); |
79 }; | 79 }; |
80 | 80 |
81 class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager { | 81 class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager { |
82 public: | 82 public: |
83 TestingHttpServerPropertiesManager( | 83 TestingHttpServerPropertiesManager( |
84 HttpServerPropertiesManager::PrefDelegate* pref_delegate, | 84 HttpServerPropertiesManager::PrefDelegate* pref_delegate, |
85 scoped_refptr<TestMockTimeTaskRunner> pref_task_runner, | 85 scoped_refptr<TestMockTimeTaskRunner> pref_task_runner, |
86 scoped_refptr<TestMockTimeTaskRunner> net_task_runner) | 86 scoped_refptr<TestMockTimeTaskRunner> net_task_runner, |
| 87 base::TickClock* clock) |
87 : HttpServerPropertiesManager(pref_delegate, | 88 : HttpServerPropertiesManager(pref_delegate, |
88 pref_task_runner, | 89 pref_task_runner, |
89 net_task_runner, | 90 net_task_runner, |
90 nullptr), | 91 nullptr, |
| 92 clock), |
91 pref_task_runner_(std::move(pref_task_runner)), | 93 pref_task_runner_(std::move(pref_task_runner)), |
92 net_task_runner_(std::move(net_task_runner)) { | 94 net_task_runner_(std::move(net_task_runner)) { |
93 // This call must run in the context of |net_task_runner_|. | 95 // This call must run in the context of |net_task_runner_|. |
94 TestMockTimeTaskRunner::ScopedContext scoped_context(net_task_runner_); | 96 TestMockTimeTaskRunner::ScopedContext scoped_context(net_task_runner_); |
95 HttpServerPropertiesManager::InitializeOnNetworkSequence(); | 97 HttpServerPropertiesManager::InitializeOnNetworkSequence(); |
96 } | 98 } |
97 | 99 |
98 ~TestingHttpServerPropertiesManager() override {} | 100 ~TestingHttpServerPropertiesManager() override {} |
99 | 101 |
100 // Make these methods public for testing. | 102 // Make these methods public for testing. |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 // to version 4, delete the following code. | 160 // to version 4, delete the following code. |
159 static const int kHttpServerPropertiesVersions[] = {3, 4, 5}; | 161 static const int kHttpServerPropertiesVersions[] = {3, 4, 5}; |
160 | 162 |
161 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> { | 163 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> { |
162 protected: | 164 protected: |
163 HttpServerPropertiesManagerTest() = default; | 165 HttpServerPropertiesManagerTest() = default; |
164 | 166 |
165 void SetUp() override { | 167 void SetUp() override { |
166 one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1); | 168 one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1); |
167 pref_delegate_ = new MockPrefDelegate; | 169 pref_delegate_ = new MockPrefDelegate; |
| 170 net_test_task_runner_clock_ = net_test_task_runner_->GetMockTickClock(); |
168 http_server_props_manager_.reset( | 171 http_server_props_manager_.reset( |
169 new StrictMock<TestingHttpServerPropertiesManager>( | 172 new StrictMock<TestingHttpServerPropertiesManager>( |
170 pref_delegate_, pref_test_task_runner_.task_runner(), | 173 pref_delegate_, pref_test_task_runner_.task_runner(), |
171 net_test_task_runner_)); | 174 net_test_task_runner_, net_test_task_runner_clock_.get())); |
172 | 175 |
173 EXPECT_FALSE(http_server_props_manager_->IsInitialized()); | 176 EXPECT_FALSE(http_server_props_manager_->IsInitialized()); |
174 ExpectCacheUpdate(); | 177 ExpectCacheUpdate(); |
175 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 178 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
176 pref_test_task_runner_->RunUntilIdle(); | 179 pref_test_task_runner_->RunUntilIdle(); |
177 net_test_task_runner_->RunUntilIdle(); | 180 net_test_task_runner_->RunUntilIdle(); |
178 EXPECT_TRUE(http_server_props_manager_->IsInitialized()); | 181 EXPECT_TRUE(http_server_props_manager_->IsInitialized()); |
179 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 182 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
180 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 183 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
181 } | 184 } |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
243 // Overrides the main thread's message loop with a mock tick clock. Making the | 246 // Overrides the main thread's message loop with a mock tick clock. Making the |
244 // main thread the |pref_test_task_runner_| matches expectations better than | 247 // main thread the |pref_test_task_runner_| matches expectations better than |
245 // having an independent TestMockTimeTaskRunner and makes tests easier to | 248 // having an independent TestMockTimeTaskRunner and makes tests easier to |
246 // write. | 249 // write. |
247 base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_; | 250 base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_; |
248 | 251 |
249 // Mock the net task runner as well. | 252 // Mock the net task runner as well. |
250 scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ = | 253 scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ = |
251 new TestMockTimeTaskRunner; | 254 new TestMockTimeTaskRunner; |
252 | 255 |
| 256 std::unique_ptr<base::TickClock> net_test_task_runner_clock_; |
| 257 |
253 private: | 258 private: |
254 DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManagerTest); | 259 DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManagerTest); |
255 }; | 260 }; |
256 | 261 |
257 INSTANTIATE_TEST_CASE_P(/* no prefix */, | 262 INSTANTIATE_TEST_CASE_P(/* no prefix */, |
258 HttpServerPropertiesManagerTest, | 263 HttpServerPropertiesManagerTest, |
259 ::testing::ValuesIn(kHttpServerPropertiesVersions)); | 264 ::testing::ValuesIn(kHttpServerPropertiesVersions)); |
260 | 265 |
261 TEST_P(HttpServerPropertiesManagerTest, | 266 TEST_P(HttpServerPropertiesManagerTest, |
262 SingleUpdateForTwoSpdyServerPrefChanges) { | 267 SingleUpdateForTwoSpdyServerPrefChanges) { |
(...skipping 868 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1131 EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service().port); | 1136 EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service().port); |
1132 } | 1137 } |
1133 | 1138 |
1134 // Verify SupportsQuic. | 1139 // Verify SupportsQuic. |
1135 IPAddress address; | 1140 IPAddress address; |
1136 ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address)); | 1141 ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address)); |
1137 EXPECT_EQ("127.0.0.1", address.ToString()); | 1142 EXPECT_EQ("127.0.0.1", address.ToString()); |
1138 } | 1143 } |
1139 | 1144 |
1140 TEST_P(HttpServerPropertiesManagerTest, UpdatePrefsWithCache) { | 1145 TEST_P(HttpServerPropertiesManagerTest, UpdatePrefsWithCache) { |
1141 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5); | 1146 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(7); |
1142 | 1147 |
1143 const url::SchemeHostPort server_www("https", "www.google.com", 80); | 1148 const url::SchemeHostPort server_www("https", "www.google.com", 80); |
1144 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); | 1149 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); |
1145 | 1150 |
1146 // #1 & #2: Set alternate protocol. | 1151 // #1 & #2: Set alternate protocol. |
1147 AlternativeServiceInfoVector alternative_service_info_vector; | 1152 AlternativeServiceInfoVector alternative_service_info_vector; |
1148 AlternativeService www_alternative_service1(kProtoHTTP2, "", 443); | 1153 AlternativeService www_alternative_service1(kProtoHTTP2, "", 443); |
1149 base::Time expiration1; | 1154 base::Time expiration1; |
1150 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); | 1155 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); |
1151 alternative_service_info_vector.push_back( | 1156 alternative_service_info_vector.push_back( |
1152 AlternativeServiceInfo(www_alternative_service1, expiration1)); | 1157 AlternativeServiceInfo(www_alternative_service1, expiration1)); |
1153 AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com", | 1158 AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com", |
1154 1234); | 1159 1234); |
1155 base::Time expiration2; | 1160 base::Time expiration2; |
1156 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); | 1161 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); |
1157 alternative_service_info_vector.push_back( | 1162 alternative_service_info_vector.push_back( |
1158 AlternativeServiceInfo(www_alternative_service2, expiration2)); | 1163 AlternativeServiceInfo(www_alternative_service2, expiration2)); |
1159 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( | 1164 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( |
1160 server_www, alternative_service_info_vector)); | 1165 server_www, alternative_service_info_vector)); |
1161 | 1166 |
1162 AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com", | 1167 AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com", |
1163 444); | 1168 444); |
1164 base::Time expiration3 = base::Time::Max(); | 1169 base::Time expiration3 = base::Time::Max(); |
1165 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( | 1170 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( |
1166 server_mail, mail_alternative_service, expiration3)); | 1171 server_mail, mail_alternative_service, expiration3)); |
1167 | 1172 |
1168 // #3: Set ServerNetworkStats. | 1173 // #3 & #4: Mark alternate protocol broken/recently broken. |
| 1174 { |
| 1175 base::TestMockTimeTaskRunner::ScopedContext net_test_task_runner_context( |
| 1176 net_test_task_runner_); |
| 1177 |
| 1178 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1179 www_alternative_service2); |
| 1180 http_server_props_manager_->MarkAlternativeServiceRecentlyBroken( |
| 1181 mail_alternative_service); |
| 1182 } |
| 1183 |
| 1184 // #5: Set ServerNetworkStats. |
1169 ServerNetworkStats stats; | 1185 ServerNetworkStats stats; |
1170 stats.srtt = base::TimeDelta::FromInternalValue(42); | 1186 stats.srtt = base::TimeDelta::FromInternalValue(42); |
1171 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); | 1187 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); |
1172 | 1188 |
1173 // #4: Set quic_server_info string. | 1189 // #6: Set quic_server_info string. |
1174 QuicServerId mail_quic_server_id("mail.google.com", 80); | 1190 QuicServerId mail_quic_server_id("mail.google.com", 80); |
1175 std::string quic_server_info1("quic_server_info1"); | 1191 std::string quic_server_info1("quic_server_info1"); |
1176 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, | 1192 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
1177 quic_server_info1); | 1193 quic_server_info1); |
1178 | 1194 |
1179 // #5: Set SupportsQuic. | 1195 // #7: Set SupportsQuic. |
1180 IPAddress actual_address(127, 0, 0, 1); | 1196 IPAddress actual_address(127, 0, 0, 1); |
1181 http_server_props_manager_->SetSupportsQuic(true, actual_address); | 1197 http_server_props_manager_->SetSupportsQuic(true, actual_address); |
1182 | 1198 |
| 1199 base::Time time_before_prefs_update = base::Time::Now(); |
| 1200 |
1183 // Update Prefs. | 1201 // Update Prefs. |
| 1202 // |net_test_task_runner_| has a remaining pending task to expire |
| 1203 // |www_alternative_service2| in 5 minutes. Fast forward enough such |
| 1204 // that the prefs update task is executed but not the task to expire |
| 1205 // |broken_alternative_service|. |
1184 ExpectPrefsUpdate(1); | 1206 ExpectPrefsUpdate(1); |
1185 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); | 1207 EXPECT_EQ(2u, net_test_task_runner_->GetPendingTaskCount()); |
1186 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1208 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1187 net_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1209 net_test_task_runner_->FastForwardBy( |
| 1210 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
| 1211 EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount()); |
1188 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1212 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1189 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1213 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1190 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1214 EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount()); |
1191 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1215 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1192 | 1216 |
1193 // Verify preferences. | 1217 base::Time time_after_prefs_update = base::Time::Now(); |
| 1218 |
| 1219 // Verify |pref_delegate_|'s server dict. |
| 1220 // In HttpServerPropertiesManager, broken alternative services' expiration |
| 1221 // times are converted from TimeTicks to Time before being written to JSON by |
| 1222 // using the difference between Time::Now() and TimeTicks::Now(). |
| 1223 // To verify these expiration times, |time_before_prefs_update| and |
| 1224 // |time_after_prefs_update| provide lower and upper bounds for the |
| 1225 // Time::Now() value used by the manager for this conversion. |
| 1226 // |
| 1227 // A copy of |pref_delegate_|'s server dict will be created, and the broken |
| 1228 // alternative service's "broken_until" field is removed and verified |
| 1229 // separately. The rest of the server dict copy is verified afterwards. |
| 1230 base::Value server_value_copy(pref_delegate_->GetServerProperties()); |
| 1231 |
| 1232 // Extract and remove the "broken_until" string for "www.google.com:1234". |
| 1233 base::DictionaryValue* server_dict; |
| 1234 ASSERT_TRUE(server_value_copy.GetAsDictionary(&server_dict)); |
| 1235 base::ListValue* broken_alt_svc_list; |
| 1236 ASSERT_TRUE(server_dict->GetList("broken_alternative_services", |
| 1237 &broken_alt_svc_list)); |
| 1238 ASSERT_EQ(2u, broken_alt_svc_list->GetSize()); |
| 1239 base::DictionaryValue* broken_alt_svcs_list_entry; |
| 1240 ASSERT_TRUE( |
| 1241 broken_alt_svc_list->GetDictionary(0, &broken_alt_svcs_list_entry)); |
| 1242 ASSERT_TRUE(broken_alt_svcs_list_entry->HasKey("broken_until")); |
| 1243 std::string expiration_string; |
| 1244 ASSERT_TRUE(broken_alt_svcs_list_entry->GetStringWithoutPathExpansion( |
| 1245 "broken_until", &expiration_string)); |
| 1246 broken_alt_svcs_list_entry->RemoveWithoutPathExpansion("broken_until", |
| 1247 nullptr); |
| 1248 |
| 1249 // Expiration time of "www.google.com:1234" should be 5 minutes minus the |
| 1250 // update-prefs-delay from when the prefs were written. |
| 1251 int64_t expiration_int64; |
| 1252 ASSERT_TRUE(base::StringToInt64(expiration_string, &expiration_int64)); |
| 1253 base::TimeDelta expiration_delta = |
| 1254 base::TimeDelta::FromMinutes(5) - |
| 1255 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting(); |
| 1256 time_t time_t_of_prefs_update = static_cast<time_t>(expiration_int64); |
| 1257 EXPECT_LE((time_before_prefs_update + expiration_delta).ToTimeT(), |
| 1258 time_t_of_prefs_update); |
| 1259 EXPECT_GE((time_after_prefs_update + expiration_delta).ToTimeT(), |
| 1260 time_t_of_prefs_update); |
| 1261 |
| 1262 // Verify all other preferences. |
1194 const char expected_json[] = | 1263 const char expected_json[] = |
1195 "{\"quic_servers\":{\"https://" | 1264 "{" |
1196 "mail.google.com:80\":{\"server_info\":\"quic_server_info1\"}}," | 1265 "\"broken_alternative_services\":" |
| 1266 "[{\"broken_count\":1,\"host\":\"www.google.com\",\"port\":1234," |
| 1267 "\"protocol_str\":\"h2\"}," |
| 1268 "{\"broken_count\":1,\"host\":\"foo.google.com\",\"port\":444," |
| 1269 "\"protocol_str\":\"h2\"}]," |
| 1270 "\"quic_servers\":" |
| 1271 "{\"https://mail.google.com:80\":" |
| 1272 "{\"server_info\":\"quic_server_info1\"}}," |
1197 "\"servers\":[" | 1273 "\"servers\":[" |
1198 "{\"https://www.google.com:80\":{" | 1274 "{\"https://www.google.com:80\":{" |
1199 "\"alternative_service\":[{\"expiration\":\"13756212000000000\"," | 1275 "\"alternative_service\":[{\"expiration\":\"13756212000000000\"," |
1200 "\"port\":443,\"protocol_str\":\"h2\"}," | 1276 "\"port\":443,\"protocol_str\":\"h2\"}," |
1201 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," | 1277 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," |
1202 "\"port\":1234,\"protocol_str\":\"h2\"}]}}," | 1278 "\"port\":1234,\"protocol_str\":\"h2\"}]}}," |
1203 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" | 1279 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" |
1204 "\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," | 1280 "\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," |
1205 "\"port\":444,\"protocol_str\":\"h2\"}]," | 1281 "\"port\":444,\"protocol_str\":\"h2\"}]," |
1206 "\"network_stats\":{\"srtt\":42}}}" | 1282 "\"network_stats\":{\"srtt\":42}}}" |
1207 "]," | 1283 "]," |
1208 "\"supports_quic\":{\"address\":\"127.0.0.1\",\"used_quic\":true}," | 1284 "\"supports_quic\":" |
1209 "\"version\":5}"; | 1285 "{\"address\":\"127.0.0.1\",\"used_quic\":true}," |
| 1286 "\"version\":5" |
| 1287 "}"; |
1210 | 1288 |
1211 const base::Value* http_server_properties = | |
1212 &pref_delegate_->GetServerProperties(); | |
1213 std::string preferences_json; | 1289 std::string preferences_json; |
1214 EXPECT_TRUE( | 1290 EXPECT_TRUE(base::JSONWriter::Write(server_value_copy, &preferences_json)); |
1215 base::JSONWriter::Write(*http_server_properties, &preferences_json)); | |
1216 EXPECT_EQ(expected_json, preferences_json); | 1291 EXPECT_EQ(expected_json, preferences_json); |
1217 } | 1292 } |
1218 | 1293 |
1219 TEST_P(HttpServerPropertiesManagerTest, | 1294 TEST_P(HttpServerPropertiesManagerTest, |
1220 SingleCacheUpdateForMultipleUpdatesScheduled) { | 1295 SingleCacheUpdateForMultipleUpdatesScheduled) { |
1221 // Update cache. | 1296 // Update cache. |
1222 ExpectCacheUpdate(); | 1297 ExpectCacheUpdate(); |
1223 | 1298 |
1224 EXPECT_EQ(0u, pref_test_task_runner_->GetPendingTaskCount()); | 1299 EXPECT_EQ(0u, pref_test_task_runner_->GetPendingTaskCount()); |
1225 // Update cache. | 1300 // Update cache. |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1315 | 1390 |
1316 const url::SchemeHostPort server("http", "example.com", 80); | 1391 const url::SchemeHostPort server("http", "example.com", 80); |
1317 AlternativeServiceMap alternative_service_map(/*max_size=*/5); | 1392 AlternativeServiceMap alternative_service_map(/*max_size=*/5); |
1318 EXPECT_FALSE(http_server_props_manager_->AddToAlternativeServiceMap( | 1393 EXPECT_FALSE(http_server_props_manager_->AddToAlternativeServiceMap( |
1319 server, *server_dict, &alternative_service_map)); | 1394 server, *server_dict, &alternative_service_map)); |
1320 | 1395 |
1321 AlternativeServiceMap::iterator it = alternative_service_map.Get(server); | 1396 AlternativeServiceMap::iterator it = alternative_service_map.Get(server); |
1322 EXPECT_EQ(alternative_service_map.end(), it); | 1397 EXPECT_EQ(alternative_service_map.end(), it); |
1323 } | 1398 } |
1324 | 1399 |
1325 // Do not persist expired or broken alternative service entries to disk. | 1400 // Do not persist expired alternative service entries to disk. |
1326 TEST_P(HttpServerPropertiesManagerTest, | 1401 TEST_P(HttpServerPropertiesManagerTest, DoNotPersistExpiredAlternativeService) { |
1327 DoNotPersistExpiredOrBrokenAlternativeService) { | |
1328 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(2); | 1402 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(2); |
1329 | 1403 |
1330 { | 1404 { |
1331 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); | 1405 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
1332 | 1406 |
1333 AlternativeServiceInfoVector alternative_service_info_vector; | 1407 AlternativeServiceInfoVector alternative_service_info_vector; |
1334 | 1408 |
1335 const AlternativeService broken_alternative_service( | 1409 const AlternativeService broken_alternative_service( |
1336 kProtoHTTP2, "broken.example.com", 443); | 1410 kProtoHTTP2, "broken.example.com", 443); |
1337 const base::Time time_one_day_later = | 1411 const base::Time time_one_day_later = |
(...skipping 22 matching lines...) Expand all Loading... |
1360 server, alternative_service_info_vector)); | 1434 server, alternative_service_info_vector)); |
1361 } | 1435 } |
1362 | 1436 |
1363 // Update cache. | 1437 // Update cache. |
1364 ExpectPrefsUpdate(1); | 1438 ExpectPrefsUpdate(1); |
1365 | 1439 |
1366 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); | 1440 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
1367 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1441 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1368 | 1442 |
1369 // |net_test_task_runner_| has a remaining pending task to expire | 1443 // |net_test_task_runner_| has a remaining pending task to expire |
1370 // |broken_alternative_service| |time_one_day_later| (and the impl uses | 1444 // |broken_alternative_service| at |time_one_day_later|. Fast forward enough |
1371 // TimeTicks::Now() without a mock clock so FastForwardUntilNoTasksRemain() | 1445 // such that the prefs update task is executed but not the task to expire |
1372 // would result in an infinite loop). | 1446 // |broken_alternative_service|. |
| 1447 EXPECT_EQ(2U, net_test_task_runner_->GetPendingTaskCount()); |
1373 net_test_task_runner_->FastForwardBy( | 1448 net_test_task_runner_->FastForwardBy( |
1374 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); | 1449 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
1375 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); | 1450 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); |
1376 | 1451 |
1377 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1452 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1378 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1453 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1379 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); | 1454 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); |
1380 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1455 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1381 | 1456 |
1382 const base::DictionaryValue& pref_dict = | 1457 const base::DictionaryValue& pref_dict = |
1383 pref_delegate_->GetServerProperties(); | 1458 pref_delegate_->GetServerProperties(); |
1384 | 1459 |
1385 const base::ListValue* servers_list = nullptr; | 1460 const base::ListValue* servers_list = nullptr; |
1386 ASSERT_TRUE(pref_dict.GetListWithoutPathExpansion("servers", &servers_list)); | 1461 ASSERT_TRUE(pref_dict.GetListWithoutPathExpansion("servers", &servers_list)); |
1387 base::ListValue::const_iterator it = servers_list->begin(); | 1462 base::ListValue::const_iterator it = servers_list->begin(); |
1388 const base::DictionaryValue* server_pref_dict; | 1463 const base::DictionaryValue* server_pref_dict; |
1389 ASSERT_TRUE(it->GetAsDictionary(&server_pref_dict)); | 1464 ASSERT_TRUE(it->GetAsDictionary(&server_pref_dict)); |
1390 | 1465 |
1391 const base::DictionaryValue* example_pref_dict; | 1466 const base::DictionaryValue* example_pref_dict; |
1392 | 1467 |
1393 ASSERT_TRUE(server_pref_dict->GetDictionaryWithoutPathExpansion( | 1468 ASSERT_TRUE(server_pref_dict->GetDictionaryWithoutPathExpansion( |
1394 "https://www.example.com", &example_pref_dict)); | 1469 "https://www.example.com", &example_pref_dict)); |
1395 | 1470 |
1396 const base::ListValue* altsvc_list; | 1471 const base::ListValue* altsvc_list; |
1397 ASSERT_TRUE(example_pref_dict->GetList("alternative_service", &altsvc_list)); | 1472 ASSERT_TRUE(example_pref_dict->GetList("alternative_service", &altsvc_list)); |
1398 | 1473 |
1399 ASSERT_EQ(1u, altsvc_list->GetSize()); | 1474 ASSERT_EQ(2u, altsvc_list->GetSize()); |
1400 | 1475 |
1401 const base::DictionaryValue* altsvc_entry; | 1476 const base::DictionaryValue* altsvc_entry; |
| 1477 std::string hostname; |
| 1478 |
1402 ASSERT_TRUE(altsvc_list->GetDictionary(0, &altsvc_entry)); | 1479 ASSERT_TRUE(altsvc_list->GetDictionary(0, &altsvc_entry)); |
| 1480 ASSERT_TRUE(altsvc_entry->GetString("host", &hostname)); |
| 1481 EXPECT_EQ("broken.example.com", hostname); |
1403 | 1482 |
1404 std::string hostname; | 1483 ASSERT_TRUE(altsvc_list->GetDictionary(1, &altsvc_entry)); |
1405 ASSERT_TRUE(altsvc_entry->GetString("host", &hostname)); | 1484 ASSERT_TRUE(altsvc_entry->GetString("host", &hostname)); |
1406 EXPECT_EQ("valid.example.com", hostname); | 1485 EXPECT_EQ("valid.example.com", hostname); |
1407 } | 1486 } |
1408 | 1487 |
1409 // Test that expired alternative service entries on disk are ignored. | 1488 // Test that expired alternative service entries on disk are ignored. |
1410 TEST_P(HttpServerPropertiesManagerTest, DoNotLoadExpiredAlternativeService) { | 1489 TEST_P(HttpServerPropertiesManagerTest, DoNotLoadExpiredAlternativeService) { |
1411 auto alternative_service_list = base::MakeUnique<base::ListValue>(); | 1490 auto alternative_service_list = base::MakeUnique<base::ListValue>(); |
1412 auto expired_dict = base::MakeUnique<base::DictionaryValue>(); | 1491 auto expired_dict = base::MakeUnique<base::DictionaryValue>(); |
1413 expired_dict->SetString("protocol_str", "h2"); | 1492 expired_dict->SetString("protocol_str", "h2"); |
1414 expired_dict->SetString("host", "expired.example.com"); | 1493 expired_dict->SetString("host", "expired.example.com"); |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1543 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1622 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1544 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1623 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1545 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1624 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1546 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1625 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1547 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); | 1626 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); |
1548 http_server_props_manager_.reset(); | 1627 http_server_props_manager_.reset(); |
1549 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1628 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1550 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1629 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1551 } | 1630 } |
1552 | 1631 |
| 1632 TEST_P(HttpServerPropertiesManagerTest, UpdateCacheWithPrefs) { |
| 1633 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(3); |
| 1634 |
| 1635 AlternativeService cached_broken_service(kProtoQUIC, "cached_broken", 443); |
| 1636 AlternativeService cached_broken_service2(kProtoQUIC, "cached_broken2", 443); |
| 1637 AlternativeService cached_recently_broken_service(kProtoQUIC, |
| 1638 "cached_rbroken", 443); |
| 1639 |
| 1640 { |
| 1641 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1642 |
| 1643 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1644 cached_broken_service); |
| 1645 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1646 cached_broken_service2); |
| 1647 http_server_props_manager_->MarkAlternativeServiceRecentlyBroken( |
| 1648 cached_recently_broken_service); |
| 1649 } |
| 1650 ExpectPrefsUpdate(1); |
| 1651 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1652 // Run the prefs update task but not the expiration task for |
| 1653 // |cached_broken_service|. |
| 1654 net_test_task_runner_->FastForwardBy( |
| 1655 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
| 1656 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1657 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1658 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1659 |
| 1660 // Load the |pref_delegate_| with some JSON to verify updating the cache from |
| 1661 // prefs. For the broken alternative services "www.google.com:1234" and |
| 1662 // "cached_broken", the expiration time will be one day from now. |
| 1663 |
| 1664 std::string expiration_str = |
| 1665 base::Int64ToString(static_cast<int64_t>(one_day_from_now_.ToTimeT())); |
| 1666 |
| 1667 std::unique_ptr<base::Value> server_value = base::JSONReader::Read( |
| 1668 "{" |
| 1669 "\"broken_alternative_services\":[" |
| 1670 "{\"broken_count\":1,\"broken_until\":\"" + |
| 1671 expiration_str + |
| 1672 "\"," |
| 1673 "\"host\":\"www.google.com\",\"port\":1234,\"protocol_str\":\"h2\"}," |
| 1674 "{\"broken_count\":2,\"broken_until\":\"" + |
| 1675 expiration_str + |
| 1676 "\"," |
| 1677 "\"host\":\"cached_broken\",\"port\":443,\"protocol_str\":\"quic\"}," |
| 1678 "{\"broken_count\":3," |
| 1679 "\"host\":\"cached_rbroken\",\"port\":443,\"protocol_str\":\"quic\"}]," |
| 1680 "\"quic_servers\":{" |
| 1681 "\"https://mail.google.com:80\":{" |
| 1682 "\"server_info\":\"quic_server_info1\"}" |
| 1683 "}," |
| 1684 "\"servers\":[" |
| 1685 "{\"https://www.google.com:80\":{" |
| 1686 "\"alternative_service\":[" |
| 1687 "{\"expiration\":\"13756212000000000\",\"port\":443," |
| 1688 "\"protocol_str\":\"h2\"}," |
| 1689 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," |
| 1690 "\"port\":1234,\"protocol_str\":\"h2\"}" |
| 1691 "]" |
| 1692 "}}," |
| 1693 "{\"https://mail.google.com:80\":{" |
| 1694 "\"alternative_service\":[" |
| 1695 "{\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," |
| 1696 "\"port\":444,\"protocol_str\":\"h2\"}" |
| 1697 "]," |
| 1698 "\"network_stats\":{\"srtt\":42}" |
| 1699 "}}" |
| 1700 "]," |
| 1701 "\"supports_quic\":" |
| 1702 "{\"address\":\"127.0.0.1\",\"used_quic\":true}," |
| 1703 "\"version\":5" |
| 1704 "}"); |
| 1705 ASSERT_TRUE(server_value); |
| 1706 base::DictionaryValue* server_dict; |
| 1707 ASSERT_TRUE(server_value->GetAsDictionary(&server_dict)); |
| 1708 |
| 1709 pref_delegate_->SetPrefs(*server_dict); |
| 1710 |
| 1711 ExpectCacheUpdate(); |
| 1712 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1713 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1714 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1715 // Run the cache update task but not the expiration task for |
| 1716 // |cached_broken_service|. |
| 1717 net_test_task_runner_->FastForwardBy( |
| 1718 net_test_task_runner_->NextPendingTaskDelay()); |
| 1719 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1720 |
| 1721 // |
| 1722 // Verify alternative service info for https://www.google.com |
| 1723 // |
| 1724 AlternativeServiceInfoVector alternative_service_info_vector = |
| 1725 http_server_props_manager_->GetAlternativeServiceInfos( |
| 1726 url::SchemeHostPort("https", "www.google.com", 80)); |
| 1727 ASSERT_EQ(2u, alternative_service_info_vector.size()); |
| 1728 |
| 1729 EXPECT_EQ(kProtoHTTP2, |
| 1730 alternative_service_info_vector[0].alternative_service().protocol); |
| 1731 EXPECT_EQ("www.google.com", |
| 1732 alternative_service_info_vector[0].alternative_service().host); |
| 1733 EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service().port); |
| 1734 EXPECT_EQ( |
| 1735 "13756212000000000", |
| 1736 base::Int64ToString( |
| 1737 alternative_service_info_vector[0].expiration().ToInternalValue())); |
| 1738 |
| 1739 EXPECT_EQ(kProtoHTTP2, |
| 1740 alternative_service_info_vector[1].alternative_service().protocol); |
| 1741 EXPECT_EQ("www.google.com", |
| 1742 alternative_service_info_vector[1].alternative_service().host); |
| 1743 EXPECT_EQ(1234, |
| 1744 alternative_service_info_vector[1].alternative_service().port); |
| 1745 EXPECT_EQ( |
| 1746 "13758804000000000", |
| 1747 base::Int64ToString( |
| 1748 alternative_service_info_vector[1].expiration().ToInternalValue())); |
| 1749 |
| 1750 // |
| 1751 // Verify alternative service info for https://mail.google.com |
| 1752 // |
| 1753 alternative_service_info_vector = |
| 1754 http_server_props_manager_->GetAlternativeServiceInfos( |
| 1755 url::SchemeHostPort("https", "mail.google.com", 80)); |
| 1756 ASSERT_EQ(1u, alternative_service_info_vector.size()); |
| 1757 |
| 1758 EXPECT_EQ(kProtoHTTP2, |
| 1759 alternative_service_info_vector[0].alternative_service().protocol); |
| 1760 EXPECT_EQ("foo.google.com", |
| 1761 alternative_service_info_vector[0].alternative_service().host); |
| 1762 EXPECT_EQ(444, alternative_service_info_vector[0].alternative_service().port); |
| 1763 EXPECT_EQ( |
| 1764 "9223372036854775807", |
| 1765 base::Int64ToString( |
| 1766 alternative_service_info_vector[0].expiration().ToInternalValue())); |
| 1767 |
| 1768 // |
| 1769 // Verify broken alternative services. |
| 1770 // |
| 1771 AlternativeService prefs_broken_service(kProtoHTTP2, "www.google.com", 1234); |
| 1772 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1773 cached_broken_service)); |
| 1774 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1775 cached_broken_service2)); |
| 1776 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1777 prefs_broken_service)); |
| 1778 // Verify brokenness expiration times. |
| 1779 // |cached_broken_service|'s expiration time should've been overwritten by the |
| 1780 // prefs to be approximately 1 day from now. |cached_broken_service2|'s |
| 1781 // expiration time should still be 5 minutes due to being marked broken. |
| 1782 // |prefs_broken_service|'s expiration time should be approximately 1 day from |
| 1783 // now which comes from the prefs. |
| 1784 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(4)); |
| 1785 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1786 cached_broken_service)); |
| 1787 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1788 cached_broken_service2)); |
| 1789 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1790 prefs_broken_service)); |
| 1791 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromDays(1)); |
| 1792 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1793 cached_broken_service)); |
| 1794 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1795 cached_broken_service2)); |
| 1796 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1797 prefs_broken_service)); |
| 1798 |
| 1799 // Now that |prefs_broken_service|'s brokenness has expired, it should've |
| 1800 // been removed from the alternative services info vectors of all servers. |
| 1801 alternative_service_info_vector = |
| 1802 http_server_props_manager_->GetAlternativeServiceInfos( |
| 1803 url::SchemeHostPort("https", "www.google.com", 80)); |
| 1804 ASSERT_EQ(1u, alternative_service_info_vector.size()); |
| 1805 |
| 1806 // |
| 1807 // Verify recently broken alternative services. |
| 1808 // |
| 1809 |
| 1810 // If an entry is already in cache, the broken count in the prefs should |
| 1811 // overwrite the one in the cache. |
| 1812 // |pref_broken_service| should have broken-count 1 from prefs. |
| 1813 // |cached_recently_broken_service| should have broken-count 3 from prefs. |
| 1814 // |cached_broken_service| should have broken-count 2 from prefs. |
| 1815 // |cached_broken_service2| should have broken-count 1 from being marked |
| 1816 // broken. |
| 1817 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(4); |
| 1818 ExpectPrefsUpdate(4); |
| 1819 |
| 1820 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1821 prefs_broken_service)); |
| 1822 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1823 cached_recently_broken_service)); |
| 1824 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1825 cached_broken_service)); |
| 1826 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1827 cached_broken_service2)); |
| 1828 // Make sure |pref_broken_service| has the right expiration delay when marked |
| 1829 // broken. |
| 1830 { |
| 1831 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1832 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1833 prefs_broken_service); |
| 1834 } |
| 1835 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1836 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(10) - |
| 1837 base::TimeDelta::FromInternalValue(1)); |
| 1838 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1839 prefs_broken_service)); |
| 1840 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1841 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1842 prefs_broken_service)); |
| 1843 // Make sure |cached_recently_broken_service| has the right expiration delay |
| 1844 // when marked broken. |
| 1845 { |
| 1846 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1847 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1848 cached_recently_broken_service); |
| 1849 } |
| 1850 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1851 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(40) - |
| 1852 base::TimeDelta::FromInternalValue(1)); |
| 1853 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1854 cached_recently_broken_service)); |
| 1855 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1856 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1857 cached_recently_broken_service)); |
| 1858 // Make sure |cached_broken_service| has the right expiration delay when |
| 1859 // marked broken. |
| 1860 { |
| 1861 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1862 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1863 cached_broken_service); |
| 1864 } |
| 1865 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1866 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(20) - |
| 1867 base::TimeDelta::FromInternalValue(1)); |
| 1868 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1869 cached_broken_service)); |
| 1870 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1871 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1872 cached_broken_service)); |
| 1873 // Make sure |cached_broken_service2| has the right expiration delay when |
| 1874 // marked broken. |
| 1875 { |
| 1876 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1877 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1878 cached_broken_service2); |
| 1879 } |
| 1880 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1881 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(10) - |
| 1882 base::TimeDelta::FromInternalValue(1)); |
| 1883 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1884 cached_broken_service2)); |
| 1885 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1886 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1887 cached_broken_service2)); |
| 1888 |
| 1889 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); |
| 1890 |
| 1891 // |
| 1892 // Verify ServerNetworkStats. |
| 1893 // |
| 1894 const ServerNetworkStats* server_network_stats = |
| 1895 http_server_props_manager_->GetServerNetworkStats( |
| 1896 url::SchemeHostPort("https", "mail.google.com", 80)); |
| 1897 EXPECT_TRUE(server_network_stats); |
| 1898 EXPECT_EQ(server_network_stats->srtt, base::TimeDelta::FromInternalValue(42)); |
| 1899 |
| 1900 // |
| 1901 // Verify QUIC server info. |
| 1902 // |
| 1903 const std::string* quic_server_info = |
| 1904 http_server_props_manager_->GetQuicServerInfo( |
| 1905 QuicServerId("mail.google.com", 80)); |
| 1906 EXPECT_EQ("quic_server_info1", *quic_server_info); |
| 1907 |
| 1908 // |
| 1909 // Verify supports QUIC. |
| 1910 // |
| 1911 IPAddress actual_address(127, 0, 0, 1); |
| 1912 EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&actual_address)); |
| 1913 } |
| 1914 |
1553 } // namespace net | 1915 } // namespace net |
OLD | NEW |