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 151 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
162 HttpServerPropertiesManagerTest() = default; | 162 HttpServerPropertiesManagerTest() = default; |
163 | 163 |
164 void SetUp() override { | 164 void SetUp() override { |
165 one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1); | 165 one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1); |
166 pref_delegate_ = new MockPrefDelegate; | 166 pref_delegate_ = new MockPrefDelegate; |
167 http_server_props_manager_.reset( | 167 http_server_props_manager_.reset( |
168 new StrictMock<TestingHttpServerPropertiesManager>( | 168 new StrictMock<TestingHttpServerPropertiesManager>( |
169 pref_delegate_, pref_test_task_runner_.task_runner(), | 169 pref_delegate_, pref_test_task_runner_.task_runner(), |
170 net_test_task_runner_)); | 170 net_test_task_runner_)); |
171 | 171 |
| 172 net_test_task_runner_clock_ = net_test_task_runner_->GetMockTickClock(); |
| 173 http_server_props_manager_->SetTickClockForTesting( |
| 174 net_test_task_runner_clock_.get()); |
| 175 |
172 EXPECT_FALSE(http_server_props_manager_->IsInitialized()); | 176 EXPECT_FALSE(http_server_props_manager_->IsInitialized()); |
173 ExpectCacheUpdate(); | 177 ExpectCacheUpdate(); |
174 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 178 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
175 pref_test_task_runner_->RunUntilIdle(); | 179 pref_test_task_runner_->RunUntilIdle(); |
176 net_test_task_runner_->RunUntilIdle(); | 180 net_test_task_runner_->RunUntilIdle(); |
177 EXPECT_TRUE(http_server_props_manager_->IsInitialized()); | 181 EXPECT_TRUE(http_server_props_manager_->IsInitialized()); |
178 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 182 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
179 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 183 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
180 } | 184 } |
181 | 185 |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
242 // 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 |
243 // main thread the |pref_test_task_runner_| matches expectations better than | 247 // main thread the |pref_test_task_runner_| matches expectations better than |
244 // having an independent TestMockTimeTaskRunner and makes tests easier to | 248 // having an independent TestMockTimeTaskRunner and makes tests easier to |
245 // write. | 249 // write. |
246 base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_; | 250 base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_; |
247 | 251 |
248 // Mock the net task runner as well. | 252 // Mock the net task runner as well. |
249 scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ = | 253 scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ = |
250 new TestMockTimeTaskRunner; | 254 new TestMockTimeTaskRunner; |
251 | 255 |
| 256 std::unique_ptr<base::TickClock> net_test_task_runner_clock_; |
| 257 |
252 private: | 258 private: |
253 DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManagerTest); | 259 DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManagerTest); |
254 }; | 260 }; |
255 | 261 |
256 INSTANTIATE_TEST_CASE_P(/* no prefix */, | 262 INSTANTIATE_TEST_CASE_P(/* no prefix */, |
257 HttpServerPropertiesManagerTest, | 263 HttpServerPropertiesManagerTest, |
258 ::testing::ValuesIn(kHttpServerPropertiesVersions)); | 264 ::testing::ValuesIn(kHttpServerPropertiesVersions)); |
259 | 265 |
260 TEST_P(HttpServerPropertiesManagerTest, | 266 TEST_P(HttpServerPropertiesManagerTest, |
261 SingleUpdateForTwoSpdyServerPrefChanges) { | 267 SingleUpdateForTwoSpdyServerPrefChanges) { |
(...skipping 721 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
983 } | 989 } |
984 | 990 |
985 TEST_P(HttpServerPropertiesManagerTest, Clear) { | 991 TEST_P(HttpServerPropertiesManagerTest, Clear) { |
986 ExpectPrefsUpdate(1); | 992 ExpectPrefsUpdate(1); |
987 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5); | 993 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5); |
988 | 994 |
989 const url::SchemeHostPort spdy_server("https", "mail.google.com", 443); | 995 const url::SchemeHostPort spdy_server("https", "mail.google.com", 443); |
990 const IPAddress actual_address(127, 0, 0, 1); | 996 const IPAddress actual_address(127, 0, 0, 1); |
991 const QuicServerId mail_quic_server_id("mail.google.com", 80); | 997 const QuicServerId mail_quic_server_id("mail.google.com", 80); |
992 const std::string quic_server_info1("quic_server_info1"); | 998 const std::string quic_server_info1("quic_server_info1"); |
993 | 999 const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com", |
| 1000 1234); |
| 1001 const AlternativeService broken_alternative_service( |
| 1002 kProtoHTTP2, "broken.google.com", 1234); |
994 { | 1003 { |
995 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); | 1004 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
996 | 1005 |
| 1006 http_server_props_manager_->SetAlternativeServices( |
| 1007 spdy_server, |
| 1008 {AlternativeServiceInfo(alternative_service, one_day_from_now_), |
| 1009 AlternativeServiceInfo(broken_alternative_service, |
| 1010 one_day_from_now_)}); |
| 1011 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1012 broken_alternative_service); |
997 http_server_props_manager_->SetSupportsSpdy(spdy_server, true); | 1013 http_server_props_manager_->SetSupportsSpdy(spdy_server, true); |
998 AlternativeService alternative_service(kProtoHTTP2, "mail.google.com", | |
999 1234); | |
1000 http_server_props_manager_->SetAlternativeService( | |
1001 spdy_server, alternative_service, one_day_from_now_); | |
1002 http_server_props_manager_->SetSupportsQuic(true, actual_address); | 1014 http_server_props_manager_->SetSupportsQuic(true, actual_address); |
1003 ServerNetworkStats stats; | 1015 ServerNetworkStats stats; |
1004 stats.srtt = base::TimeDelta::FromMicroseconds(10); | 1016 stats.srtt = base::TimeDelta::FromMicroseconds(10); |
1005 http_server_props_manager_->SetServerNetworkStats(spdy_server, stats); | 1017 http_server_props_manager_->SetServerNetworkStats(spdy_server, stats); |
1006 | 1018 |
1007 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, | 1019 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
1008 quic_server_info1); | 1020 quic_server_info1); |
1009 } | 1021 } |
1010 | 1022 |
1011 // Run the task. | 1023 // Advance time by just enough so that the prefs update task is executed but |
| 1024 // not the task to expire the brokenness of |broken_alternative_service|. |
1012 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1025 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1013 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); | 1026 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
1014 net_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1027 net_test_task_runner_->FastForwardBy( |
1015 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1028 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
| 1029 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
1016 | 1030 |
| 1031 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1032 broken_alternative_service)); |
1017 EXPECT_TRUE(http_server_props_manager_->SupportsRequestPriority(spdy_server)); | 1033 EXPECT_TRUE(http_server_props_manager_->SupportsRequestPriority(spdy_server)); |
1018 EXPECT_TRUE(HasAlternativeService(spdy_server)); | 1034 EXPECT_TRUE(HasAlternativeService(spdy_server)); |
1019 IPAddress address; | 1035 IPAddress address; |
1020 EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&address)); | 1036 EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&address)); |
1021 EXPECT_EQ(actual_address, address); | 1037 EXPECT_EQ(actual_address, address); |
1022 const ServerNetworkStats* stats1 = | 1038 const ServerNetworkStats* stats1 = |
1023 http_server_props_manager_->GetServerNetworkStats(spdy_server); | 1039 http_server_props_manager_->GetServerNetworkStats(spdy_server); |
1024 EXPECT_EQ(10, stats1->srtt.ToInternalValue()); | 1040 EXPECT_EQ(10, stats1->srtt.ToInternalValue()); |
1025 EXPECT_EQ(quic_server_info1, *http_server_props_manager_->GetQuicServerInfo( | 1041 EXPECT_EQ(quic_server_info1, *http_server_props_manager_->GetQuicServerInfo( |
1026 mail_quic_server_id)); | 1042 mail_quic_server_id)); |
1027 | 1043 |
1028 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); | 1044 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); |
1029 | 1045 |
1030 ExpectPrefsUpdate(1); | 1046 ExpectPrefsUpdate(1); |
1031 | 1047 |
1032 // Clear http server data and run the ensuing non-delayed prefs update. | 1048 // Clear http server data and run the ensuing non-delayed prefs update. |
1033 { | 1049 { |
1034 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); | 1050 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
1035 http_server_props_manager_->Clear(); | 1051 http_server_props_manager_->Clear(); |
1036 } | 1052 } |
1037 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1053 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1038 pref_test_task_runner_->RunUntilIdle(); | 1054 pref_test_task_runner_->RunUntilIdle(); |
1039 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1055 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1040 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | |
1041 | 1056 |
| 1057 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1058 broken_alternative_service)); |
1042 EXPECT_FALSE( | 1059 EXPECT_FALSE( |
1043 http_server_props_manager_->SupportsRequestPriority(spdy_server)); | 1060 http_server_props_manager_->SupportsRequestPriority(spdy_server)); |
1044 EXPECT_FALSE(HasAlternativeService(spdy_server)); | 1061 EXPECT_FALSE(HasAlternativeService(spdy_server)); |
1045 EXPECT_FALSE(http_server_props_manager_->GetSupportsQuic(&address)); | 1062 EXPECT_FALSE(http_server_props_manager_->GetSupportsQuic(&address)); |
1046 const ServerNetworkStats* stats2 = | 1063 const ServerNetworkStats* stats2 = |
1047 http_server_props_manager_->GetServerNetworkStats(spdy_server); | 1064 http_server_props_manager_->GetServerNetworkStats(spdy_server); |
1048 EXPECT_EQ(nullptr, stats2); | 1065 EXPECT_EQ(nullptr, stats2); |
1049 EXPECT_EQ(nullptr, | 1066 EXPECT_EQ(nullptr, |
1050 http_server_props_manager_->GetQuicServerInfo(mail_quic_server_id)); | 1067 http_server_props_manager_->GetQuicServerInfo(mail_quic_server_id)); |
1051 | 1068 |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1150 EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service.port); | 1167 EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service.port); |
1151 } | 1168 } |
1152 | 1169 |
1153 // Verify SupportsQuic. | 1170 // Verify SupportsQuic. |
1154 IPAddress address; | 1171 IPAddress address; |
1155 ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address)); | 1172 ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address)); |
1156 EXPECT_EQ("127.0.0.1", address.ToString()); | 1173 EXPECT_EQ("127.0.0.1", address.ToString()); |
1157 } | 1174 } |
1158 | 1175 |
1159 TEST_P(HttpServerPropertiesManagerTest, UpdatePrefsWithCache) { | 1176 TEST_P(HttpServerPropertiesManagerTest, UpdatePrefsWithCache) { |
1160 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5); | 1177 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(7); |
1161 | 1178 |
1162 const url::SchemeHostPort server_www("https", "www.google.com", 80); | 1179 const url::SchemeHostPort server_www("https", "www.google.com", 80); |
1163 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); | 1180 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); |
1164 | 1181 |
1165 // #1 & #2: Set alternate protocol. | 1182 // #1 & #2: Set alternate protocol. |
1166 AlternativeServiceInfoVector alternative_service_info_vector; | 1183 AlternativeServiceInfoVector alternative_service_info_vector; |
1167 AlternativeService www_alternative_service1(kProtoHTTP2, "", 443); | 1184 AlternativeService www_alternative_service1(kProtoHTTP2, "", 443); |
1168 base::Time expiration1; | 1185 base::Time expiration1; |
1169 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); | 1186 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); |
1170 alternative_service_info_vector.push_back( | 1187 alternative_service_info_vector.push_back( |
1171 AlternativeServiceInfo(www_alternative_service1, expiration1)); | 1188 AlternativeServiceInfo(www_alternative_service1, expiration1)); |
1172 AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com", | 1189 AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com", |
1173 1234); | 1190 1234); |
1174 base::Time expiration2; | 1191 base::Time expiration2; |
1175 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); | 1192 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); |
1176 alternative_service_info_vector.push_back( | 1193 alternative_service_info_vector.push_back( |
1177 AlternativeServiceInfo(www_alternative_service2, expiration2)); | 1194 AlternativeServiceInfo(www_alternative_service2, expiration2)); |
1178 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( | 1195 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( |
1179 server_www, alternative_service_info_vector)); | 1196 server_www, alternative_service_info_vector)); |
1180 | 1197 |
1181 AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com", | 1198 AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com", |
1182 444); | 1199 444); |
1183 base::Time expiration3 = base::Time::Max(); | 1200 base::Time expiration3 = base::Time::Max(); |
1184 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( | 1201 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( |
1185 server_mail, mail_alternative_service, expiration3)); | 1202 server_mail, mail_alternative_service, expiration3)); |
1186 | 1203 |
1187 // #3: Set ServerNetworkStats. | 1204 // #3 & #4: Mark alternate protocol broken/recently broken. |
| 1205 { |
| 1206 base::TestMockTimeTaskRunner::ScopedContext net_test_task_runner_context( |
| 1207 net_test_task_runner_); |
| 1208 |
| 1209 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1210 www_alternative_service2); |
| 1211 http_server_props_manager_->MarkAlternativeServiceRecentlyBroken( |
| 1212 mail_alternative_service); |
| 1213 } |
| 1214 |
| 1215 // #5: Set ServerNetworkStats. |
1188 ServerNetworkStats stats; | 1216 ServerNetworkStats stats; |
1189 stats.srtt = base::TimeDelta::FromInternalValue(42); | 1217 stats.srtt = base::TimeDelta::FromInternalValue(42); |
1190 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); | 1218 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); |
1191 | 1219 |
1192 // #4: Set quic_server_info string. | 1220 // #6: Set quic_server_info string. |
1193 QuicServerId mail_quic_server_id("mail.google.com", 80); | 1221 QuicServerId mail_quic_server_id("mail.google.com", 80); |
1194 std::string quic_server_info1("quic_server_info1"); | 1222 std::string quic_server_info1("quic_server_info1"); |
1195 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, | 1223 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
1196 quic_server_info1); | 1224 quic_server_info1); |
1197 | 1225 |
1198 // #5: Set SupportsQuic. | 1226 // #7: Set SupportsQuic. |
1199 IPAddress actual_address(127, 0, 0, 1); | 1227 IPAddress actual_address(127, 0, 0, 1); |
1200 http_server_props_manager_->SetSupportsQuic(true, actual_address); | 1228 http_server_props_manager_->SetSupportsQuic(true, actual_address); |
1201 | 1229 |
1202 // Update Prefs. | 1230 // Update Prefs. |
| 1231 // |net_test_task_runner_| has a remaining pending task to expire |
| 1232 // |www_alternative_service2| in 5 minutes. Fast forward enough such |
| 1233 // that the prefs update task is executed but not the task to expire |
| 1234 // |broken_alternative_service|. |
1203 ExpectPrefsUpdate(1); | 1235 ExpectPrefsUpdate(1); |
1204 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); | 1236 EXPECT_EQ(2u, net_test_task_runner_->GetPendingTaskCount()); |
1205 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1237 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1206 net_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1238 net_test_task_runner_->FastForwardBy( |
| 1239 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
| 1240 EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount()); |
1207 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1241 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1208 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1242 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1209 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1243 EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount()); |
1210 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1244 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1211 | 1245 |
| 1246 // Verify |pref_delegate_|'s server dict. |
| 1247 // Broken alternative services' expiration times are converted from TimeTicks |
| 1248 // to Time before being written to JSON by using the difference between |
| 1249 // Time::Now() and TimeTicks::Now(). Since there's currently no dependency |
| 1250 // injection for Time::Now(), there's no straightforward way of figuring out |
| 1251 // what the expiration time should be in JSON. Because of this, the brokenness |
| 1252 // expiration time of alternative services will not be verified. A copy of |
| 1253 // |pref_delegate_|'s server dict will be created, and the broken alternative |
| 1254 // service's expiration time will be replaced with a placeholder string before |
| 1255 // comparison. |
| 1256 |
| 1257 base::Value server_value_copy(pref_delegate_->GetServerProperties()); |
| 1258 |
| 1259 base::DictionaryValue* server_dict; |
| 1260 ASSERT_TRUE(server_value_copy.GetAsDictionary(&server_dict)); |
| 1261 base::ListValue* broken_alt_svc_list; |
| 1262 ASSERT_TRUE(server_dict->GetList("broken_alternative_services", |
| 1263 &broken_alt_svc_list)); |
| 1264 EXPECT_EQ(1u, broken_alt_svc_list->GetSize()); |
| 1265 base::DictionaryValue* broken_alt_svcs_list_entry; |
| 1266 ASSERT_TRUE( |
| 1267 broken_alt_svc_list->GetDictionary(0, &broken_alt_svcs_list_entry)); |
| 1268 EXPECT_EQ(1u, broken_alt_svcs_list_entry->size()); |
| 1269 std::string broken_alt_svcs_list_entry_expiration_str; |
| 1270 EXPECT_TRUE(broken_alt_svcs_list_entry->GetStringWithoutPathExpansion( |
| 1271 "h2 www.google.com:1234", &broken_alt_svcs_list_entry_expiration_str)); |
| 1272 broken_alt_svcs_list_entry->SetStringWithoutPathExpansion( |
| 1273 "h2 www.google.com:1234", "NOT CHECKED"); |
| 1274 |
1212 // Verify preferences. | 1275 // Verify preferences. |
1213 const char expected_json[] = | 1276 const char expected_json[] = |
1214 "{\"quic_servers\":{\"https://" | 1277 "{" |
1215 "mail.google.com:80\":{\"server_info\":\"quic_server_info1\"}}," | 1278 "\"broken_alternative_services\":" |
| 1279 "[{\"h2 www.google.com:1234\":\"NOT CHECKED\"}]," |
| 1280 "\"quic_servers\":" |
| 1281 "{\"https://mail.google.com:80\":" |
| 1282 "{\"server_info\":\"quic_server_info1\"}}," |
| 1283 "\"recently_broken_alternative_services\":" |
| 1284 "[{\"h2 www.google.com:1234\":1},{\"h2 foo.google.com:444\":1}]," |
1216 "\"servers\":[" | 1285 "\"servers\":[" |
1217 "{\"https://www.google.com:80\":{" | 1286 "{\"https://www.google.com:80\":{" |
1218 "\"alternative_service\":[{\"expiration\":\"13756212000000000\"," | 1287 "\"alternative_service\":[{\"expiration\":\"13756212000000000\"," |
1219 "\"port\":443,\"protocol_str\":\"h2\"}," | 1288 "\"port\":443,\"protocol_str\":\"h2\"}," |
1220 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," | 1289 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," |
1221 "\"port\":1234,\"protocol_str\":\"h2\"}]}}," | 1290 "\"port\":1234,\"protocol_str\":\"h2\"}]}}," |
1222 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" | 1291 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" |
1223 "\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," | 1292 "\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," |
1224 "\"port\":444,\"protocol_str\":\"h2\"}]," | 1293 "\"port\":444,\"protocol_str\":\"h2\"}]," |
1225 "\"network_stats\":{\"srtt\":42}}}" | 1294 "\"network_stats\":{\"srtt\":42}}}" |
1226 "]," | 1295 "]," |
1227 "\"supports_quic\":{\"address\":\"127.0.0.1\",\"used_quic\":true}," | 1296 "\"supports_quic\":" |
1228 "\"version\":5}"; | 1297 "{\"address\":\"127.0.0.1\",\"used_quic\":true}," |
| 1298 "\"version\":5" |
| 1299 "}"; |
1229 | 1300 |
1230 const base::Value* http_server_properties = | |
1231 &pref_delegate_->GetServerProperties(); | |
1232 std::string preferences_json; | 1301 std::string preferences_json; |
1233 EXPECT_TRUE( | 1302 EXPECT_TRUE(base::JSONWriter::Write(server_value_copy, &preferences_json)); |
1234 base::JSONWriter::Write(*http_server_properties, &preferences_json)); | |
1235 EXPECT_EQ(expected_json, preferences_json); | 1303 EXPECT_EQ(expected_json, preferences_json); |
1236 } | 1304 } |
1237 | 1305 |
1238 TEST_P(HttpServerPropertiesManagerTest, | 1306 TEST_P(HttpServerPropertiesManagerTest, |
1239 SingleCacheUpdateForMultipleUpdatesScheduled) { | 1307 SingleCacheUpdateForMultipleUpdatesScheduled) { |
1240 // Update cache. | 1308 // Update cache. |
1241 ExpectCacheUpdate(); | 1309 ExpectCacheUpdate(); |
1242 | 1310 |
1243 EXPECT_EQ(0u, pref_test_task_runner_->GetPendingTaskCount()); | 1311 EXPECT_EQ(0u, pref_test_task_runner_->GetPendingTaskCount()); |
1244 // Update cache. | 1312 // Update cache. |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1332 | 1400 |
1333 const url::SchemeHostPort server("http", "example.com", 80); | 1401 const url::SchemeHostPort server("http", "example.com", 80); |
1334 AlternativeServiceMap alternative_service_map(/*max_size=*/5); | 1402 AlternativeServiceMap alternative_service_map(/*max_size=*/5); |
1335 EXPECT_FALSE(http_server_props_manager_->AddToAlternativeServiceMap( | 1403 EXPECT_FALSE(http_server_props_manager_->AddToAlternativeServiceMap( |
1336 server, *server_dict, &alternative_service_map)); | 1404 server, *server_dict, &alternative_service_map)); |
1337 | 1405 |
1338 AlternativeServiceMap::iterator it = alternative_service_map.Get(server); | 1406 AlternativeServiceMap::iterator it = alternative_service_map.Get(server); |
1339 EXPECT_EQ(alternative_service_map.end(), it); | 1407 EXPECT_EQ(alternative_service_map.end(), it); |
1340 } | 1408 } |
1341 | 1409 |
1342 // Do not persist expired or broken alternative service entries to disk. | 1410 // Do not persist expired alternative service entries to disk. |
1343 TEST_P(HttpServerPropertiesManagerTest, | 1411 TEST_P(HttpServerPropertiesManagerTest, DoNotPersistExpiredAlternativeService) { |
1344 DoNotPersistExpiredOrBrokenAlternativeService) { | |
1345 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(2); | 1412 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(2); |
1346 | 1413 |
1347 { | 1414 { |
1348 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); | 1415 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
1349 | 1416 |
1350 AlternativeServiceInfoVector alternative_service_info_vector; | 1417 AlternativeServiceInfoVector alternative_service_info_vector; |
1351 | 1418 |
1352 const AlternativeService broken_alternative_service( | 1419 const AlternativeService broken_alternative_service( |
1353 kProtoHTTP2, "broken.example.com", 443); | 1420 kProtoHTTP2, "broken.example.com", 443); |
1354 const base::Time time_one_day_later = | 1421 const base::Time time_one_day_later = |
(...skipping 22 matching lines...) Expand all Loading... |
1377 server, alternative_service_info_vector)); | 1444 server, alternative_service_info_vector)); |
1378 } | 1445 } |
1379 | 1446 |
1380 // Update cache. | 1447 // Update cache. |
1381 ExpectPrefsUpdate(1); | 1448 ExpectPrefsUpdate(1); |
1382 | 1449 |
1383 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); | 1450 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
1384 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1451 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1385 | 1452 |
1386 // |net_test_task_runner_| has a remaining pending task to expire | 1453 // |net_test_task_runner_| has a remaining pending task to expire |
1387 // |broken_alternative_service| |time_one_day_later| (and the impl uses | 1454 // |broken_alternative_service| |time_one_day_later|. Fast forward enough such |
1388 // TimeTicks::Now() without a mock clock so FastForwardUntilNoTasksRemain() | 1455 // that the prefs update task is executed but not the task to expire |
1389 // would result in an infinite loop). | 1456 // |broken_alternative_service|. |
| 1457 EXPECT_EQ(2U, net_test_task_runner_->GetPendingTaskCount()); |
1390 net_test_task_runner_->FastForwardBy( | 1458 net_test_task_runner_->FastForwardBy( |
1391 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); | 1459 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
1392 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); | 1460 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); |
1393 | 1461 |
1394 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1462 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1395 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1463 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1396 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); | 1464 EXPECT_EQ(1U, net_test_task_runner_->GetPendingTaskCount()); |
1397 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1465 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1398 | 1466 |
1399 const base::DictionaryValue& pref_dict = | 1467 const base::DictionaryValue& pref_dict = |
1400 pref_delegate_->GetServerProperties(); | 1468 pref_delegate_->GetServerProperties(); |
1401 | 1469 |
1402 const base::ListValue* servers_list = nullptr; | 1470 const base::ListValue* servers_list = nullptr; |
1403 ASSERT_TRUE(pref_dict.GetListWithoutPathExpansion("servers", &servers_list)); | 1471 ASSERT_TRUE(pref_dict.GetListWithoutPathExpansion("servers", &servers_list)); |
1404 base::ListValue::const_iterator it = servers_list->begin(); | 1472 base::ListValue::const_iterator it = servers_list->begin(); |
1405 const base::DictionaryValue* server_pref_dict; | 1473 const base::DictionaryValue* server_pref_dict; |
1406 ASSERT_TRUE(it->GetAsDictionary(&server_pref_dict)); | 1474 ASSERT_TRUE(it->GetAsDictionary(&server_pref_dict)); |
1407 | 1475 |
1408 const base::DictionaryValue* example_pref_dict; | 1476 const base::DictionaryValue* example_pref_dict; |
1409 | 1477 |
1410 ASSERT_TRUE(server_pref_dict->GetDictionaryWithoutPathExpansion( | 1478 ASSERT_TRUE(server_pref_dict->GetDictionaryWithoutPathExpansion( |
1411 "https://www.example.com", &example_pref_dict)); | 1479 "https://www.example.com", &example_pref_dict)); |
1412 | 1480 |
1413 const base::ListValue* altsvc_list; | 1481 const base::ListValue* altsvc_list; |
1414 ASSERT_TRUE(example_pref_dict->GetList("alternative_service", &altsvc_list)); | 1482 ASSERT_TRUE(example_pref_dict->GetList("alternative_service", &altsvc_list)); |
1415 | 1483 |
1416 ASSERT_EQ(1u, altsvc_list->GetSize()); | 1484 ASSERT_EQ(2u, altsvc_list->GetSize()); |
1417 | 1485 |
1418 const base::DictionaryValue* altsvc_entry; | 1486 const base::DictionaryValue* altsvc_entry; |
| 1487 std::string hostname; |
| 1488 |
1419 ASSERT_TRUE(altsvc_list->GetDictionary(0, &altsvc_entry)); | 1489 ASSERT_TRUE(altsvc_list->GetDictionary(0, &altsvc_entry)); |
| 1490 ASSERT_TRUE(altsvc_entry->GetString("host", &hostname)); |
| 1491 EXPECT_EQ("broken.example.com", hostname); |
1420 | 1492 |
1421 std::string hostname; | 1493 ASSERT_TRUE(altsvc_list->GetDictionary(1, &altsvc_entry)); |
1422 ASSERT_TRUE(altsvc_entry->GetString("host", &hostname)); | 1494 ASSERT_TRUE(altsvc_entry->GetString("host", &hostname)); |
1423 EXPECT_EQ("valid.example.com", hostname); | 1495 EXPECT_EQ("valid.example.com", hostname); |
1424 } | 1496 } |
1425 | 1497 |
1426 // Test that expired alternative service entries on disk are ignored. | 1498 // Test that expired alternative service entries on disk are ignored. |
1427 TEST_P(HttpServerPropertiesManagerTest, DoNotLoadExpiredAlternativeService) { | 1499 TEST_P(HttpServerPropertiesManagerTest, DoNotLoadExpiredAlternativeService) { |
1428 auto alternative_service_list = base::MakeUnique<base::ListValue>(); | 1500 auto alternative_service_list = base::MakeUnique<base::ListValue>(); |
1429 auto expired_dict = base::MakeUnique<base::DictionaryValue>(); | 1501 auto expired_dict = base::MakeUnique<base::DictionaryValue>(); |
1430 expired_dict->SetString("protocol_str", "h2"); | 1502 expired_dict->SetString("protocol_str", "h2"); |
1431 expired_dict->SetString("host", "expired.example.com"); | 1503 expired_dict->SetString("host", "expired.example.com"); |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1560 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1632 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1561 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1633 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1562 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1634 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1563 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1635 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1564 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); | 1636 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); |
1565 http_server_props_manager_.reset(); | 1637 http_server_props_manager_.reset(); |
1566 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1638 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1567 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1639 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1568 } | 1640 } |
1569 | 1641 |
| 1642 TEST_P(HttpServerPropertiesManagerTest, UpdateCacheWithPrefs) { |
| 1643 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(3); |
| 1644 |
| 1645 AlternativeService broken_service(kProtoQUIC, "cached_broken", 443); |
| 1646 AlternativeService broken_service2(kProtoQUIC, "cached_broken2", 443); |
| 1647 AlternativeService recently_broken_service(kProtoQUIC, "cached_rbroken", 443); |
| 1648 |
| 1649 { |
| 1650 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1651 |
| 1652 http_server_props_manager_->MarkAlternativeServiceBroken(broken_service); |
| 1653 http_server_props_manager_->MarkAlternativeServiceBroken(broken_service2); |
| 1654 http_server_props_manager_->MarkAlternativeServiceRecentlyBroken( |
| 1655 recently_broken_service); |
| 1656 } |
| 1657 ExpectPrefsUpdate(1); |
| 1658 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1659 // Run the prefs update task but not the expiration task for |broken_service|. |
| 1660 net_test_task_runner_->FastForwardBy( |
| 1661 HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting()); |
| 1662 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1663 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1664 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1665 |
| 1666 // Load the |pref_delegate_| with some JSON to verify updating the cache from |
| 1667 // prefs. For the broken alternative service "www.google.com:1234", the |
| 1668 // expiration time will be computed to be |
| 1669 |
| 1670 std::string expiration_str = |
| 1671 base::Int64ToString(static_cast<int64_t>(one_day_from_now_.ToTimeT())); |
| 1672 |
| 1673 std::unique_ptr<base::Value> server_value = base::JSONReader::Read( |
| 1674 "{" |
| 1675 "\"broken_alternative_services\":[" |
| 1676 "{\"h2 www.google.com:1234\":\"" + |
| 1677 expiration_str + |
| 1678 "\"}," |
| 1679 "{\"quic cached_broken:443\":\"" + |
| 1680 expiration_str + |
| 1681 "\"}]," |
| 1682 "\"quic_servers\":{" |
| 1683 "\"https://mail.google.com:80\":{" |
| 1684 "\"server_info\":\"quic_server_info1\"" |
| 1685 "}" |
| 1686 "}," |
| 1687 "\"recently_broken_alternative_services\":[" |
| 1688 "{\"h2 www.google.com:1234\":1}," |
| 1689 "{\"quic cached_broken:443\":2}," |
| 1690 "{\"quic cached_rbroken:443\":3}]," |
| 1691 "\"servers\":[" |
| 1692 "{\"https://www.google.com:80\":{" |
| 1693 "\"alternative_service\":[" |
| 1694 "{\"expiration\":\"13756212000000000\",\"port\":443," |
| 1695 "\"protocol_str\":\"h2\"}," |
| 1696 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," |
| 1697 "\"port\":1234,\"protocol_str\":\"h2\"}" |
| 1698 "]" |
| 1699 "}}," |
| 1700 "{\"https://mail.google.com:80\":{" |
| 1701 "\"alternative_service\":[" |
| 1702 "{\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," |
| 1703 "\"port\":444,\"protocol_str\":\"h2\"}" |
| 1704 "]," |
| 1705 "\"network_stats\":{\"srtt\":42}" |
| 1706 "}}" |
| 1707 "]," |
| 1708 "\"supports_quic\":" |
| 1709 "{\"address\":\"127.0.0.1\",\"used_quic\":true}," |
| 1710 "\"version\":5" |
| 1711 "}"); |
| 1712 ASSERT_TRUE(server_value); |
| 1713 base::DictionaryValue* server_dict; |
| 1714 ASSERT_TRUE(server_value->GetAsDictionary(&server_dict)); |
| 1715 |
| 1716 pref_delegate_->SetPrefs(*server_dict); |
| 1717 |
| 1718 ExpectCacheUpdate(); |
| 1719 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1720 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1721 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1722 // Run the cache update task but not the expiration task for |broken_service|. |
| 1723 net_test_task_runner_->FastForwardBy( |
| 1724 net_test_task_runner_->NextPendingTaskDelay()); |
| 1725 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1726 |
| 1727 // |
| 1728 // Verify alternative service info for https://www.google.com |
| 1729 // |
| 1730 AlternativeServiceInfoVector alternative_service_info_vector = |
| 1731 http_server_props_manager_->GetAlternativeServiceInfos( |
| 1732 url::SchemeHostPort("https", "www.google.com", 80)); |
| 1733 ASSERT_EQ(2u, alternative_service_info_vector.size()); |
| 1734 |
| 1735 EXPECT_EQ(kProtoHTTP2, |
| 1736 alternative_service_info_vector[0].alternative_service.protocol); |
| 1737 EXPECT_EQ("www.google.com", |
| 1738 alternative_service_info_vector[0].alternative_service.host); |
| 1739 EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service.port); |
| 1740 EXPECT_EQ( |
| 1741 "13756212000000000", |
| 1742 base::Int64ToString( |
| 1743 alternative_service_info_vector[0].expiration.ToInternalValue())); |
| 1744 |
| 1745 EXPECT_EQ(kProtoHTTP2, |
| 1746 alternative_service_info_vector[1].alternative_service.protocol); |
| 1747 EXPECT_EQ("www.google.com", |
| 1748 alternative_service_info_vector[1].alternative_service.host); |
| 1749 EXPECT_EQ(1234, alternative_service_info_vector[1].alternative_service.port); |
| 1750 EXPECT_EQ( |
| 1751 "13758804000000000", |
| 1752 base::Int64ToString( |
| 1753 alternative_service_info_vector[1].expiration.ToInternalValue())); |
| 1754 |
| 1755 // |
| 1756 // Verify alternative service info for https://mail.google.com |
| 1757 // |
| 1758 alternative_service_info_vector = |
| 1759 http_server_props_manager_->GetAlternativeServiceInfos( |
| 1760 url::SchemeHostPort("https", "mail.google.com", 80)); |
| 1761 ASSERT_EQ(1u, alternative_service_info_vector.size()); |
| 1762 |
| 1763 EXPECT_EQ(kProtoHTTP2, |
| 1764 alternative_service_info_vector[0].alternative_service.protocol); |
| 1765 EXPECT_EQ("foo.google.com", |
| 1766 alternative_service_info_vector[0].alternative_service.host); |
| 1767 EXPECT_EQ(444, alternative_service_info_vector[0].alternative_service.port); |
| 1768 EXPECT_EQ( |
| 1769 "9223372036854775807", |
| 1770 base::Int64ToString( |
| 1771 alternative_service_info_vector[0].expiration.ToInternalValue())); |
| 1772 |
| 1773 // |
| 1774 // Verify broken alternative services. |
| 1775 // |
| 1776 AlternativeService prefs_broken_service(kProtoHTTP2, "www.google.com", 1234); |
| 1777 EXPECT_TRUE( |
| 1778 http_server_props_manager_->IsAlternativeServiceBroken(broken_service)); |
| 1779 EXPECT_TRUE( |
| 1780 http_server_props_manager_->IsAlternativeServiceBroken(broken_service2)); |
| 1781 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1782 prefs_broken_service)); |
| 1783 // Verify brokenness expiration times. |
| 1784 // |broken_service|'s expiration time should've been overwritten by the prefs |
| 1785 // to be approximately 1 day from now. |
| 1786 // |broken_service2|'s expiration time should still be 5 minutes due to being |
| 1787 // marked broken. |
| 1788 // |prefs_broken_service|'s expiration time should be approximately 1 day from |
| 1789 // now which comes from the prefs. |
| 1790 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(4)); |
| 1791 EXPECT_TRUE( |
| 1792 http_server_props_manager_->IsAlternativeServiceBroken(broken_service)); |
| 1793 EXPECT_FALSE( |
| 1794 http_server_props_manager_->IsAlternativeServiceBroken(broken_service2)); |
| 1795 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1796 prefs_broken_service)); |
| 1797 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromDays(1)); |
| 1798 EXPECT_FALSE( |
| 1799 http_server_props_manager_->IsAlternativeServiceBroken(broken_service)); |
| 1800 EXPECT_FALSE( |
| 1801 http_server_props_manager_->IsAlternativeServiceBroken(broken_service2)); |
| 1802 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1803 prefs_broken_service)); |
| 1804 |
| 1805 // Now that |prefs_broken_service|'s brokenness has expired, it should've |
| 1806 // been removed from the alternative services info vectors of all servers. |
| 1807 alternative_service_info_vector = |
| 1808 http_server_props_manager_->GetAlternativeServiceInfos( |
| 1809 url::SchemeHostPort("https", "www.google.com", 80)); |
| 1810 ASSERT_EQ(1u, alternative_service_info_vector.size()); |
| 1811 |
| 1812 // |
| 1813 // Verify recently broken alternative services. |
| 1814 // |
| 1815 |
| 1816 // If an entry is already in cache, the broken count in the prefs should |
| 1817 // overwrite the one in the cache. |
| 1818 // The entries already in the cache should remain at the front of the recency |
| 1819 // list. |
| 1820 // |pref_broken_service| should have broken-count 1 from prefs. |
| 1821 // |recently_broken_service| should have broken-count 3 from prefs. |
| 1822 // |broken_service| should have broken-count 2 from prefs. |
| 1823 // |broken_service2| should have broken-count 1 from being marked broken. |
| 1824 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(4); |
| 1825 ExpectPrefsUpdate(4); |
| 1826 |
| 1827 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1828 prefs_broken_service)); |
| 1829 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1830 recently_broken_service)); |
| 1831 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1832 broken_service)); |
| 1833 EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
| 1834 broken_service2)); |
| 1835 // Make sure |pref_broken_service| has the right expiration delay if marked |
| 1836 // broken. |
| 1837 { |
| 1838 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1839 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1840 prefs_broken_service); |
| 1841 } |
| 1842 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1843 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(10) - |
| 1844 base::TimeDelta::FromInternalValue(1)); |
| 1845 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1846 prefs_broken_service)); |
| 1847 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1848 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1849 prefs_broken_service)); |
| 1850 // Make sure |recently_broken_service| has the right expiration delay if |
| 1851 // marked broken. |
| 1852 { |
| 1853 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1854 http_server_props_manager_->MarkAlternativeServiceBroken( |
| 1855 recently_broken_service); |
| 1856 } |
| 1857 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1858 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(40) - |
| 1859 base::TimeDelta::FromInternalValue(1)); |
| 1860 EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1861 recently_broken_service)); |
| 1862 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1863 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
| 1864 recently_broken_service)); |
| 1865 // Make sure |broken_service| has the right expiration delay if marked |
| 1866 // broken. |
| 1867 { |
| 1868 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1869 http_server_props_manager_->MarkAlternativeServiceBroken(broken_service); |
| 1870 } |
| 1871 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1872 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(20) - |
| 1873 base::TimeDelta::FromInternalValue(1)); |
| 1874 EXPECT_TRUE( |
| 1875 http_server_props_manager_->IsAlternativeServiceBroken(broken_service)); |
| 1876 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1877 EXPECT_FALSE( |
| 1878 http_server_props_manager_->IsAlternativeServiceBroken(broken_service)); |
| 1879 // Make sure |broken_service2| has the right expiration delay if marked |
| 1880 // broken. |
| 1881 { |
| 1882 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
| 1883 http_server_props_manager_->MarkAlternativeServiceBroken(broken_service2); |
| 1884 } |
| 1885 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1886 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(10) - |
| 1887 base::TimeDelta::FromInternalValue(1)); |
| 1888 EXPECT_TRUE( |
| 1889 http_server_props_manager_->IsAlternativeServiceBroken(broken_service2)); |
| 1890 net_test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1)); |
| 1891 EXPECT_FALSE( |
| 1892 http_server_props_manager_->IsAlternativeServiceBroken(broken_service2)); |
| 1893 |
| 1894 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); |
| 1895 |
| 1896 // |
| 1897 // Verify ServerNetworkStats. |
| 1898 // |
| 1899 const ServerNetworkStats* server_network_stats = |
| 1900 http_server_props_manager_->GetServerNetworkStats( |
| 1901 url::SchemeHostPort("https", "mail.google.com", 80)); |
| 1902 EXPECT_TRUE(server_network_stats); |
| 1903 EXPECT_EQ(server_network_stats->srtt, base::TimeDelta::FromInternalValue(42)); |
| 1904 |
| 1905 // |
| 1906 // Verify QUIC server info. |
| 1907 // |
| 1908 const std::string* quic_server_info = |
| 1909 http_server_props_manager_->GetQuicServerInfo( |
| 1910 QuicServerId("mail.google.com", 80)); |
| 1911 EXPECT_EQ("quic_server_info1", *quic_server_info); |
| 1912 |
| 1913 // |
| 1914 // Verify supports QUIC. |
| 1915 // |
| 1916 IPAddress actual_address(127, 0, 0, 1); |
| 1917 EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&actual_address)); |
| 1918 } |
| 1919 |
1570 } // namespace net | 1920 } // namespace net |
OLD | NEW |