xref: /aosp_15_r20/external/cronet/net/http/broken_alternative_services_unittest.cc (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b) 
1 // Copyright 2017 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "net/http/broken_alternative_services.h"
6 
7 #include <algorithm>
8 #include <vector>
9 
10 #include "base/memory/raw_ptr.h"
11 #include "base/test/test_mock_time_task_runner.h"
12 #include "base/time/tick_clock.h"
13 #include "base/time/time.h"
14 #include "net/base/network_anonymization_key.h"
15 #include "net/base/schemeful_site.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "url/gurl.h"
18 
19 namespace net {
20 
21 namespace {
22 
23 // Initial delay for broken alternative services.
24 const uint64_t kBrokenAlternativeProtocolDelaySecs = 300;
25 
26 class BrokenAlternativeServicesTest
27     : public BrokenAlternativeServices::Delegate,
28       public ::testing::Test {
29  public:
BrokenAlternativeServicesTest()30   BrokenAlternativeServicesTest()
31       : test_task_runner_(base::MakeRefCounted<base::TestMockTimeTaskRunner>()),
32         test_task_runner_context_(test_task_runner_),
33         broken_services_clock_(test_task_runner_->GetMockTickClock()),
34         broken_services_(50, this, broken_services_clock_) {
35     SchemefulSite site1(GURL("http://foo.test"));
36     SchemefulSite site2(GURL("http://bar.test"));
37     network_anonymization_key1_ =
38         NetworkAnonymizationKey::CreateSameSite(site1);
39     network_anonymization_key2_ =
40         NetworkAnonymizationKey::CreateSameSite(site2);
41   }
42 
43   // BrokenAlternativeServices::Delegate implementation
OnExpireBrokenAlternativeService(const AlternativeService & expired_alternative_service,const NetworkAnonymizationKey & network_anonymization_key)44   void OnExpireBrokenAlternativeService(
45       const AlternativeService& expired_alternative_service,
46       const NetworkAnonymizationKey& network_anonymization_key) override {
47     expired_alt_svcs_.emplace_back(expired_alternative_service,
48                                    network_anonymization_key,
49                                    true /* use_network_anonymization_key */);
50   }
51 
52   void TestExponentialBackoff(base::TimeDelta initial_delay,
53                               bool exponential_backoff_on_initial_delay);
54 
55   // All tests will run inside the scope of |test_task_runner_context_|, which
56   // means any task posted to the main message loop will run on
57   // |test_task_runner_|.
58   scoped_refptr<base::TestMockTimeTaskRunner> test_task_runner_;
59   base::TestMockTimeTaskRunner::ScopedContext test_task_runner_context_;
60 
61   raw_ptr<const base::TickClock> broken_services_clock_;
62   BrokenAlternativeServices broken_services_;
63 
64   std::vector<BrokenAlternativeService> expired_alt_svcs_;
65 
66   NetworkAnonymizationKey network_anonymization_key1_;
67   NetworkAnonymizationKey network_anonymization_key2_;
68 };
69 
TEST_F(BrokenAlternativeServicesTest,MarkBroken)70 TEST_F(BrokenAlternativeServicesTest, MarkBroken) {
71   const BrokenAlternativeService alternative_service1(
72       AlternativeService(kProtoHTTP2, "foo", 443), network_anonymization_key1_,
73       true /* use_network_anonymization_key */);
74   const BrokenAlternativeService alternative_service2(
75       AlternativeService(kProtoHTTP2, "foo", 1234), network_anonymization_key1_,
76       true /* use_network_anonymization_key */);
77   const BrokenAlternativeService alternative_service3(
78       AlternativeService(kProtoHTTP2, "foo", 443), network_anonymization_key2_,
79       true /* use_network_anonymization_key */);
80 
81   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
82   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
83   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
84 
85   broken_services_.MarkBroken(alternative_service1);
86 
87   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
88   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
89   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
90 
91   broken_services_.MarkBroken(alternative_service2);
92 
93   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
94   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
95   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
96 
97   broken_services_.MarkBroken(alternative_service3);
98 
99   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
100   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
101   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
102 
103   broken_services_.Confirm(alternative_service1);
104 
105   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
106   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
107   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
108 
109   broken_services_.Confirm(alternative_service2);
110 
111   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
112   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
113   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
114 
115   broken_services_.Confirm(alternative_service3);
116 
117   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
118   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
119   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
120 
121   EXPECT_EQ(0u, expired_alt_svcs_.size());
122 }
123 
TEST_F(BrokenAlternativeServicesTest,MarkBrokenUntilDefaultNetworkChanges)124 TEST_F(BrokenAlternativeServicesTest, MarkBrokenUntilDefaultNetworkChanges) {
125   const BrokenAlternativeService alternative_service1(
126       AlternativeService(kProtoHTTP2, "foo", 443), network_anonymization_key1_,
127       true /* use_network_anonymization_key */);
128   const BrokenAlternativeService alternative_service2(
129       AlternativeService(kProtoHTTP2, "foo", 1234), network_anonymization_key1_,
130       true /* use_network_anonymization_key */);
131   const BrokenAlternativeService alternative_service3(
132       AlternativeService(kProtoHTTP2, "foo", 443), network_anonymization_key2_,
133       true /* use_network_anonymization_key */);
134   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
135   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
136   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
137   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
138   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
139   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
140 
141   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service1);
142   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
143   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
144   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
145   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
146   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
147   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
148 
149   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service2);
150   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
151   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
152   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
153   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
154   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
155   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
156 
157   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service3);
158   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
159   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
160   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
161   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
162   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
163   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service3));
164 
165   broken_services_.Confirm(alternative_service1);
166   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
167   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
168   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
169   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
170   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
171   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service3));
172 
173   broken_services_.Confirm(alternative_service2);
174   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
175   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
176   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
177   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
178   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
179   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service3));
180 
181   broken_services_.Confirm(alternative_service3);
182   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
183   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
184   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
185   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
186   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
187   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
188 
189   EXPECT_EQ(0u, expired_alt_svcs_.size());
190 }
191 
TEST_F(BrokenAlternativeServicesTest,MarkRecentlyBroken)192 TEST_F(BrokenAlternativeServicesTest, MarkRecentlyBroken) {
193   const BrokenAlternativeService alternative_service1(
194       AlternativeService(kProtoHTTP2, "foo", 443), network_anonymization_key1_,
195       true /* use_network_anonymization_key */);
196   const BrokenAlternativeService alternative_service2(
197       AlternativeService(kProtoHTTP2, "foo", 443), network_anonymization_key2_,
198       true /* use_network_anonymization_key */);
199 
200   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
201   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
202   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
203   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
204 
205   broken_services_.MarkRecentlyBroken(alternative_service1);
206   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
207   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
208   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
209   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
210 
211   broken_services_.MarkRecentlyBroken(alternative_service2);
212   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
213   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
214   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
215   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
216 
217   broken_services_.Confirm(alternative_service1);
218   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
219   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
220   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
221   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
222 
223   broken_services_.Confirm(alternative_service2);
224   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
225   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
226   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
227   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
228 }
229 
TEST_F(BrokenAlternativeServicesTest,OnDefaultNetworkChanged)230 TEST_F(BrokenAlternativeServicesTest, OnDefaultNetworkChanged) {
231   BrokenAlternativeService alternative_service1(
232       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key1_,
233       true /* use_network_anonymization_key */);
234   BrokenAlternativeService alternative_service2(
235       AlternativeService(kProtoQUIC, "bar", 443), network_anonymization_key1_,
236       true /* use_network_anonymization_key */);
237   BrokenAlternativeService alternative_service3(
238       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key2_,
239       true /* use_network_anonymization_key */);
240 
241   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
242   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
243   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
244   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
245   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
246   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
247 
248   // Mark |alternative_service1| as broken until default network changes.
249   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service1);
250   // |alternative_service1| should be considered as currently broken and
251   // recently broken.
252   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
253   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
254   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
255   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
256   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
257   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
258   // |broken_services_| should have posted task to expire the brokenness of
259   // |alternative_service1|.
260   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
261 
262   // Advance time until one second before |alternative_service1|'s brokenness
263   // expires.
264   test_task_runner_->FastForwardBy(base::Minutes(5) - base::Seconds(1));
265   // |alternative_service1| should still be considered as currently broken and
266   // recently broken.
267   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
268   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
269 
270   // Advance another second and |alternative_service1|'s brokenness expires.
271   test_task_runner_->FastForwardBy(base::Seconds(1));
272   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
273   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
274 
275   // Mark |alternative_service2| as broken until default network changes.
276   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service2);
277   // |alternative_service2| should be considered as currently broken and
278   // recently broken.
279   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
280   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
281   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
282   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
283   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
284   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service3));
285 
286   // Mark |alternative_service3| as broken.
287   broken_services_.MarkBroken(alternative_service3);
288   // |alternative_service2| should be considered as currently broken and
289   // recently broken.
290   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
291   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service3));
292   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
293   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
294   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
295   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
296 
297   // Deliver the message that a default network has changed.
298   broken_services_.OnDefaultNetworkChanged();
299   // Recently broken until default network change alternative service is moved
300   // to working state.
301   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
302   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
303   // Currently broken until default network change alternative service is moved
304   // to working state.
305   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
306   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
307   // Broken alternative service is not affected by the default network change.
308   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
309   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service3));
310 }
311 
TEST_F(BrokenAlternativeServicesTest,ExpireBrokenAlternativeServiceOnDefaultNetwork)312 TEST_F(BrokenAlternativeServicesTest,
313        ExpireBrokenAlternativeServiceOnDefaultNetwork) {
314   BrokenAlternativeService alternative_service(
315       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key1_,
316       true /* use_network_anonymization_key */);
317 
318   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service);
319 
320   // |broken_services_| should have posted task to expire the brokenness of
321   // |alternative_service|.
322   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
323 
324   // Advance time until one time quantum before |alternative_service1|'s
325   // brokenness expires.
326   test_task_runner_->FastForwardBy(base::Minutes(5) - base::Seconds(1));
327 
328   // Ensure |alternative_service| is still marked broken.
329   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
330   EXPECT_EQ(0u, expired_alt_svcs_.size());
331   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
332 
333   // Advance time by one time quantum.
334   test_task_runner_->FastForwardBy(base::Seconds(1));
335 
336   // Ensure |alternative_service| brokenness has expired but is still
337   // considered recently broken.
338   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
339   EXPECT_FALSE(test_task_runner_->HasPendingTask());
340   EXPECT_EQ(1u, expired_alt_svcs_.size());
341   EXPECT_EQ(alternative_service.alternative_service,
342             expired_alt_svcs_[0].alternative_service);
343   EXPECT_EQ(alternative_service.network_anonymization_key,
344             expired_alt_svcs_[0].network_anonymization_key);
345   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
346 }
347 
TEST_F(BrokenAlternativeServicesTest,ExpireBrokenAlternateProtocolMappings)348 TEST_F(BrokenAlternativeServicesTest, ExpireBrokenAlternateProtocolMappings) {
349   BrokenAlternativeService alternative_service(
350       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key1_,
351       true /* use_network_anonymization_key */);
352 
353   broken_services_.MarkBroken(alternative_service);
354 
355   // |broken_services_| should have posted task to expire the brokenness of
356   // |alternative_service|.
357   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
358 
359   // Advance time until one time quantum before |alternative_service1|'s
360   // brokenness expires
361   test_task_runner_->FastForwardBy(base::Minutes(5) - base::Seconds(1));
362 
363   // Ensure |alternative_service| is still marked broken.
364   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
365   EXPECT_EQ(0u, expired_alt_svcs_.size());
366   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
367 
368   // Advance time by one time quantum.
369   test_task_runner_->FastForwardBy(base::Seconds(1));
370 
371   // Ensure |alternative_service| brokenness has expired but is still
372   // considered recently broken
373   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
374   EXPECT_FALSE(test_task_runner_->HasPendingTask());
375   EXPECT_EQ(1u, expired_alt_svcs_.size());
376   EXPECT_EQ(alternative_service.alternative_service,
377             expired_alt_svcs_[0].alternative_service);
378   EXPECT_EQ(alternative_service.network_anonymization_key,
379             expired_alt_svcs_[0].network_anonymization_key);
380   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
381 }
382 
TEST_F(BrokenAlternativeServicesTest,IsBroken)383 TEST_F(BrokenAlternativeServicesTest, IsBroken) {
384   // Tests the IsBroken() methods.
385   BrokenAlternativeService alternative_service(
386       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
387       true /* use_network_anonymization_key */);
388   base::TimeTicks brokenness_expiration;
389 
390   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
391   EXPECT_FALSE(
392       broken_services_.IsBroken(alternative_service, &brokenness_expiration));
393 
394   broken_services_.MarkBroken(alternative_service);
395   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
396   EXPECT_TRUE(
397       broken_services_.IsBroken(alternative_service, &brokenness_expiration));
398   EXPECT_EQ(broken_services_clock_->NowTicks() + base::Minutes(5),
399             brokenness_expiration);
400 
401   // Fast forward time until |alternative_service|'s brokenness expires.
402   test_task_runner_->FastForwardBy(base::Minutes(5));
403   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
404   EXPECT_FALSE(
405       broken_services_.IsBroken(alternative_service, &brokenness_expiration));
406 
407   broken_services_.MarkBroken(alternative_service);
408   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
409   EXPECT_TRUE(
410       broken_services_.IsBroken(alternative_service, &brokenness_expiration));
411   EXPECT_EQ(broken_services_clock_->NowTicks() + base::Minutes(10),
412             brokenness_expiration);
413 
414   broken_services_.Confirm(alternative_service);
415   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
416   EXPECT_FALSE(
417       broken_services_.IsBroken(alternative_service, &brokenness_expiration));
418 }
419 
420 // This test verifies that exponential backoff is applied to the expiration of
421 // broken alternative service regardless of which MarkBroken method was used.
422 // In particular, the alternative service's brokenness state is as follows:
423 // - marked broken on the default network;
424 // - brokenness expires after one delay;
425 // - marked broken;
426 // - (signal received that default network changes);
427 // - brokenness expires after two intervals.
TEST_F(BrokenAlternativeServicesTest,BrokenAfterBrokenOnDefaultNetwork)428 TEST_F(BrokenAlternativeServicesTest, BrokenAfterBrokenOnDefaultNetwork) {
429   BrokenAlternativeService alternative_service(
430       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
431       true /* use_network_anonymization_key */);
432 
433   // Mark the alternative service broken on the default network.
434   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service);
435   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
436   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
437 
438   test_task_runner_->FastForwardBy(
439       base::Seconds(kBrokenAlternativeProtocolDelaySecs) - base::Seconds(1));
440   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
441   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
442   // Expire the brokenness after the initial delay.
443   test_task_runner_->FastForwardBy(base::Seconds(1));
444   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
445   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
446 
447   // Mark the alternative service broken.
448   broken_services_.MarkBroken(alternative_service);
449   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
450   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
451 
452   // Verify that the expiration delay has been doubled.
453   test_task_runner_->FastForwardBy(
454       base::Seconds(kBrokenAlternativeProtocolDelaySecs * 2) -
455       base::Seconds(1));
456   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
457   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
458 
459   // Receive the message that the default network changes.
460   broken_services_.OnDefaultNetworkChanged();
461   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
462   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
463 
464   // Advance one more second so that the second expiration delay is reached.
465   test_task_runner_->FastForwardBy(base::Seconds(1));
466   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
467   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
468 }
469 
470 // This test verifies that exponentail backoff is applied to the expiration of
471 // broken alternative service regardless of which MarkBroken method was used.
472 // In particular, the alternative service's brokenness state is as follows:
473 // - marked broken;
474 // - brokenness expires after one delay;
475 // - marked broken on the default network;
476 // - broknenss expires after two intervals;
477 // - (signal received that default network changes);
TEST_F(BrokenAlternativeServicesTest,BrokenOnDefaultNetworkAfterBroken)478 TEST_F(BrokenAlternativeServicesTest, BrokenOnDefaultNetworkAfterBroken) {
479   BrokenAlternativeService alternative_service(
480       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
481       true /* use_network_anonymization_key */);
482 
483   // Mark the alternative service broken.
484   broken_services_.MarkBroken(alternative_service);
485   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
486   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
487 
488   test_task_runner_->FastForwardBy(
489       base::Seconds(kBrokenAlternativeProtocolDelaySecs) - base::Seconds(1));
490   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
491   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
492 
493   test_task_runner_->FastForwardBy(base::Seconds(1));
494   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
495   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
496 
497   // Mark the alternative service broken on the default network.
498   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service);
499   // Verify the expiration delay has been doubled.
500   test_task_runner_->FastForwardBy(
501       base::Seconds(kBrokenAlternativeProtocolDelaySecs * 2) -
502       base::Seconds(1));
503   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
504   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
505 
506   test_task_runner_->FastForwardBy(base::Seconds(1));
507   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
508   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
509 
510   // Receive the message that the default network changes. The alternative
511   // servicve is moved to working state.
512   broken_services_.OnDefaultNetworkChanged();
513   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
514   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service));
515 }
516 
517 // This test verifies that exponentail backoff is applied to expire alternative
518 // service that's marked broken until the default network changes. When default
519 // network changes, the exponential backoff is cleared.
TEST_F(BrokenAlternativeServicesTest,BrokenUntilDefaultNetworkChangeWithExponentialBackoff)520 TEST_F(BrokenAlternativeServicesTest,
521        BrokenUntilDefaultNetworkChangeWithExponentialBackoff) {
522   BrokenAlternativeService alternative_service(
523       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
524       true /* use_network_anonymization_key */);
525 
526   // Mark the alternative service broken on the default network.
527   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service);
528   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
529   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
530   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
531   EXPECT_EQ(base::Seconds(kBrokenAlternativeProtocolDelaySecs),
532             test_task_runner_->NextPendingTaskDelay());
533   // Expire the brokenness for the 1st time.
534   test_task_runner_->FastForwardBy(
535       base::Seconds(kBrokenAlternativeProtocolDelaySecs) - base::Seconds(1));
536   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
537   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
538   test_task_runner_->FastForwardBy(base::Seconds(1));
539   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
540   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
541 
542   // Mark the alternative service broken on the default network.
543   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service);
544   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
545   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
546   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
547   EXPECT_EQ(base::Seconds(kBrokenAlternativeProtocolDelaySecs * 2),
548             test_task_runner_->NextPendingTaskDelay());
549 
550   // Expire the brokenness for the 2nd time.
551   test_task_runner_->FastForwardBy(
552       base::Seconds(kBrokenAlternativeProtocolDelaySecs * 2) -
553       base::Seconds(1));
554   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
555   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
556   test_task_runner_->FastForwardBy(base::Seconds(1));
557   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
558   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
559 
560   // Receive the message that the default network changes. The alternative
561   // servicve is moved to working state.
562   broken_services_.OnDefaultNetworkChanged();
563   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
564   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service));
565 
566   // Mark the alternative service broken on the default network.
567   // Exponential delay is cleared.
568   broken_services_.MarkBrokenUntilDefaultNetworkChanges(alternative_service);
569   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
570   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service));
571   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
572   EXPECT_EQ(base::Seconds(kBrokenAlternativeProtocolDelaySecs),
573             test_task_runner_->NextPendingTaskDelay());
574 }
575 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff)576 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff) {
577   // Tests the exponential backoff of the computed expiration delay when an
578   // alt svc is marked broken. After being marked broken 10 times, the max
579   // expiration delay will have been reached and exponential backoff will no
580   // longer apply.
581 
582   BrokenAlternativeService alternative_service(
583       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
584       true /* use_network_anonymization_key */);
585 
586   broken_services_.MarkBroken(alternative_service);
587   test_task_runner_->FastForwardBy(base::Minutes(5) - base::Seconds(1));
588   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
589   test_task_runner_->FastForwardBy(base::Seconds(1));
590   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
591 
592   broken_services_.MarkBroken(alternative_service);
593   test_task_runner_->FastForwardBy(base::Minutes(10) - base::Seconds(1));
594   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
595   test_task_runner_->FastForwardBy(base::Seconds(1));
596   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
597 
598   broken_services_.MarkBroken(alternative_service);
599   test_task_runner_->FastForwardBy(base::Minutes(20) - base::Seconds(1));
600   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
601   test_task_runner_->FastForwardBy(base::Seconds(1));
602   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
603 
604   broken_services_.MarkBroken(alternative_service);
605   test_task_runner_->FastForwardBy(base::Minutes(40) - base::Seconds(1));
606   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
607   test_task_runner_->FastForwardBy(base::Seconds(1));
608   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
609 
610   broken_services_.MarkBroken(alternative_service);
611   test_task_runner_->FastForwardBy(base::Minutes(80) - base::Seconds(1));
612   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
613   test_task_runner_->FastForwardBy(base::Seconds(1));
614   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
615 
616   broken_services_.MarkBroken(alternative_service);
617   test_task_runner_->FastForwardBy(base::Minutes(160) - base::Seconds(1));
618   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
619   test_task_runner_->FastForwardBy(base::Seconds(1));
620   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
621 
622   broken_services_.MarkBroken(alternative_service);
623   test_task_runner_->FastForwardBy(base::Minutes(320) - base::Seconds(1));
624   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
625   test_task_runner_->FastForwardBy(base::Seconds(1));
626   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
627 
628   broken_services_.MarkBroken(alternative_service);
629   test_task_runner_->FastForwardBy(base::Minutes(640) - base::Seconds(1));
630   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
631   test_task_runner_->FastForwardBy(base::Seconds(1));
632   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
633 
634   broken_services_.MarkBroken(alternative_service);
635   test_task_runner_->FastForwardBy(base::Minutes(1280) - base::Seconds(1));
636   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
637   test_task_runner_->FastForwardBy(base::Seconds(1));
638   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
639 
640   broken_services_.MarkBroken(alternative_service);
641   test_task_runner_->FastForwardBy(base::Minutes(2560) - base::Seconds(1));
642   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
643   test_task_runner_->FastForwardBy(base::Seconds(1));
644   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
645 
646   // Max expiration delay has been reached; subsequent expiration delays from
647   // this point forward should not increase further.
648   broken_services_.MarkBroken(alternative_service);
649   test_task_runner_->FastForwardBy(base::Minutes(2880) - base::Seconds(1));
650   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
651   test_task_runner_->FastForwardBy(base::Seconds(1));
652   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
653 
654   broken_services_.MarkBroken(alternative_service);
655   test_task_runner_->FastForwardBy(base::Minutes(2880) - base::Seconds(1));
656   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
657   test_task_runner_->FastForwardBy(base::Seconds(1));
658   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
659 }
660 
TestExponentialBackoff(base::TimeDelta initial_delay,bool exponential_backoff_on_initial_delay)661 void BrokenAlternativeServicesTest::TestExponentialBackoff(
662     base::TimeDelta initial_delay,
663     bool exponential_backoff_on_initial_delay) {
664   // Tests the exponential backoff of the computed expiration delay when an
665   // alt svc is marked broken. After being marked broken 10 times, the max
666   // expiration delay will have been reached and exponential backoff will no
667   // longer apply.
668   broken_services_.SetDelayParams(initial_delay,
669                                   exponential_backoff_on_initial_delay);
670 
671   BrokenAlternativeService alternative_service(
672       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
673       true /* use_network_anonymization_key */);
674 
675   broken_services_.MarkBroken(alternative_service);
676   test_task_runner_->FastForwardBy(initial_delay - base::Seconds(1));
677   EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
678   test_task_runner_->FastForwardBy(base::Seconds(1));
679   EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
680 
681   for (size_t broken_count = 1; broken_count < 20; ++broken_count) {
682     broken_services_.MarkBroken(alternative_service);
683     base::TimeDelta broken_delay;
684     if (exponential_backoff_on_initial_delay) {
685       broken_delay = initial_delay * (1 << broken_count);
686     } else {
687       broken_delay = base::Seconds(kBrokenAlternativeProtocolDelaySecs) *
688                      (1 << (broken_count - 1));
689     }
690     if (broken_delay > base::Days(2)) {
691       broken_delay = base::Days(2);
692     }
693     test_task_runner_->FastForwardBy(broken_delay - base::Seconds(1));
694     EXPECT_TRUE(broken_services_.IsBroken(alternative_service));
695     test_task_runner_->FastForwardBy(base::Seconds(1));
696     EXPECT_FALSE(broken_services_.IsBroken(alternative_service));
697   }
698 }
699 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_OneSecond_True)700 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_OneSecond_True) {
701   TestExponentialBackoff(base::Seconds(1), true);
702 }
703 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_OneSecond_False)704 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_OneSecond_False) {
705   TestExponentialBackoff(base::Seconds(1), false);
706 }
707 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_FiveSeconds_True)708 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_FiveSeconds_True) {
709   TestExponentialBackoff(base::Seconds(5), true);
710 }
711 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_FiveSeconds_False)712 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_FiveSeconds_False) {
713   TestExponentialBackoff(base::Seconds(5), false);
714 }
715 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_TenSeconds_True)716 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_TenSeconds_True) {
717   TestExponentialBackoff(base::Seconds(10), true);
718 }
719 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_TenSeconds_False)720 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_TenSeconds_False) {
721   TestExponentialBackoff(base::Seconds(10), false);
722 }
723 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_FiveMinutes_True)724 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_FiveMinutes_True) {
725   TestExponentialBackoff(base::Seconds(kBrokenAlternativeProtocolDelaySecs),
726                          true);
727 }
728 
TEST_F(BrokenAlternativeServicesTest,ExponentialBackoff_FiveMinutes_False)729 TEST_F(BrokenAlternativeServicesTest, ExponentialBackoff_FiveMinutes_False) {
730   TestExponentialBackoff(base::Seconds(kBrokenAlternativeProtocolDelaySecs),
731                          false);
732 }
733 
TEST_F(BrokenAlternativeServicesTest,RemoveExpiredBrokenAltSvc)734 TEST_F(BrokenAlternativeServicesTest, RemoveExpiredBrokenAltSvc) {
735   // This test will mark broken an alternative service A that has already been
736   // marked broken many times, then immediately mark another alternative service
737   // B as broken for the first time. Because A's been marked broken many times
738   // already, its brokenness will be scheduled to expire much further in the
739   // future than B, even though it was marked broken before B. This test makes
740   // sure that even though A was marked broken before B, B's brokenness should
741   // expire before A.
742 
743   BrokenAlternativeService alternative_service1(
744       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key1_,
745       true /* use_network_anonymization_key */);
746   BrokenAlternativeService alternative_service2(
747       AlternativeService(kProtoQUIC, "bar", 443), network_anonymization_key2_,
748       true /* use_network_anonymization_key */);
749 
750   // Repeately mark |alternative_service1| broken and let brokenness expire.
751   // Do this a few times.
752 
753   broken_services_.MarkBroken(alternative_service1);
754   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
755   test_task_runner_->FastForwardBy(base::Minutes(5));
756   EXPECT_EQ(1u, expired_alt_svcs_.size());
757   EXPECT_EQ(alternative_service1.alternative_service,
758             expired_alt_svcs_.back().alternative_service);
759   EXPECT_EQ(alternative_service1.network_anonymization_key,
760             expired_alt_svcs_.back().network_anonymization_key);
761 
762   broken_services_.MarkBroken(alternative_service1);
763   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
764   test_task_runner_->FastForwardBy(base::Minutes(10));
765   EXPECT_EQ(2u, expired_alt_svcs_.size());
766   EXPECT_EQ(alternative_service1.alternative_service,
767             expired_alt_svcs_.back().alternative_service);
768   EXPECT_EQ(alternative_service1.network_anonymization_key,
769             expired_alt_svcs_.back().network_anonymization_key);
770 
771   broken_services_.MarkBroken(alternative_service1);
772   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
773   test_task_runner_->FastForwardBy(base::Minutes(20));
774   EXPECT_EQ(3u, expired_alt_svcs_.size());
775   EXPECT_EQ(alternative_service1.alternative_service,
776             expired_alt_svcs_.back().alternative_service);
777   EXPECT_EQ(alternative_service1.network_anonymization_key,
778             expired_alt_svcs_.back().network_anonymization_key);
779 
780   expired_alt_svcs_.clear();
781 
782   // Mark |alternative_service1| broken (will be given longer expiration delay),
783   // then mark |alternative_service2| broken (will be given shorter expiration
784   // delay).
785   broken_services_.MarkBroken(alternative_service1);
786   broken_services_.MarkBroken(alternative_service2);
787 
788   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
789   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
790 
791   // Advance time until one time quantum before |alternative_service2|'s
792   // brokenness expires.
793   test_task_runner_->FastForwardBy(base::Minutes(5) - base::Seconds(1));
794 
795   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
796   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
797   EXPECT_EQ(0u, expired_alt_svcs_.size());
798 
799   // Advance time by one time quantum. |alternative_service2| should no longer
800   // be broken.
801   test_task_runner_->FastForwardBy(base::Seconds(1));
802 
803   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
804   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
805   EXPECT_EQ(1u, expired_alt_svcs_.size());
806   EXPECT_EQ(alternative_service2.alternative_service,
807             expired_alt_svcs_[0].alternative_service);
808   EXPECT_EQ(alternative_service2.network_anonymization_key,
809             expired_alt_svcs_[0].network_anonymization_key);
810 
811   // Advance time until one time quantum before |alternative_service1|'s
812   // brokenness expires
813   test_task_runner_->FastForwardBy(base::Minutes(40) - base::Minutes(5) -
814                                    base::Seconds(1));
815 
816   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
817   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
818   EXPECT_EQ(1u, expired_alt_svcs_.size());
819   EXPECT_EQ(alternative_service2.alternative_service,
820             expired_alt_svcs_[0].alternative_service);
821   EXPECT_EQ(alternative_service2.network_anonymization_key,
822             expired_alt_svcs_[0].network_anonymization_key);
823 
824   // Advance time by one time quantum.  |alternative_service1| should no longer
825   // be broken.
826   test_task_runner_->FastForwardBy(base::Seconds(1));
827 
828   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
829   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
830   EXPECT_EQ(2u, expired_alt_svcs_.size());
831   EXPECT_EQ(alternative_service2.alternative_service,
832             expired_alt_svcs_[0].alternative_service);
833   EXPECT_EQ(alternative_service2.network_anonymization_key,
834             expired_alt_svcs_[0].network_anonymization_key);
835   EXPECT_EQ(alternative_service1.alternative_service,
836             expired_alt_svcs_[1].alternative_service);
837   EXPECT_EQ(alternative_service1.network_anonymization_key,
838             expired_alt_svcs_[1].network_anonymization_key);
839 }
840 
841 // Same as above, but checks a single alternative service with two different
842 // NetworkAnonymizationKeys.
TEST_F(BrokenAlternativeServicesTest,RemoveExpiredBrokenAltSvcWithNetworkAnonymizationKey)843 TEST_F(BrokenAlternativeServicesTest,
844        RemoveExpiredBrokenAltSvcWithNetworkAnonymizationKey) {
845   BrokenAlternativeService alternative_service1(
846       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key1_,
847       true /* use_network_anonymization_key */);
848   BrokenAlternativeService alternative_service2(
849       AlternativeService(kProtoQUIC, "foo", 443), network_anonymization_key2_,
850       true /* use_network_anonymization_key */);
851 
852   // Repeately mark |alternative_service1| broken and let brokenness expire.
853   // Do this a few times.
854 
855   broken_services_.MarkBroken(alternative_service1);
856   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
857   test_task_runner_->FastForwardBy(base::Minutes(5));
858   EXPECT_EQ(1u, expired_alt_svcs_.size());
859   EXPECT_EQ(alternative_service1.alternative_service,
860             expired_alt_svcs_.back().alternative_service);
861   EXPECT_EQ(alternative_service1.network_anonymization_key,
862             expired_alt_svcs_.back().network_anonymization_key);
863 
864   broken_services_.MarkBroken(alternative_service1);
865   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
866   test_task_runner_->FastForwardBy(base::Minutes(10));
867   EXPECT_EQ(2u, expired_alt_svcs_.size());
868   EXPECT_EQ(alternative_service1.alternative_service,
869             expired_alt_svcs_.back().alternative_service);
870   EXPECT_EQ(alternative_service1.network_anonymization_key,
871             expired_alt_svcs_.back().network_anonymization_key);
872 
873   broken_services_.MarkBroken(alternative_service1);
874   EXPECT_EQ(1u, test_task_runner_->GetPendingTaskCount());
875   test_task_runner_->FastForwardBy(base::Minutes(20));
876   EXPECT_EQ(3u, expired_alt_svcs_.size());
877   EXPECT_EQ(alternative_service1.alternative_service,
878             expired_alt_svcs_.back().alternative_service);
879   EXPECT_EQ(alternative_service1.network_anonymization_key,
880             expired_alt_svcs_.back().network_anonymization_key);
881 
882   expired_alt_svcs_.clear();
883 
884   // Mark |alternative_service1| broken (will be given longer expiration delay),
885   // then mark |alternative_service2| broken (will be given shorter expiration
886   // delay).
887   broken_services_.MarkBroken(alternative_service1);
888   broken_services_.MarkBroken(alternative_service2);
889 
890   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
891   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
892 
893   // Advance time until one time quantum before |alternative_service2|'s
894   // brokenness expires.
895   test_task_runner_->FastForwardBy(base::Minutes(5) - base::Seconds(1));
896 
897   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
898   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
899   EXPECT_EQ(0u, expired_alt_svcs_.size());
900 
901   // Advance time by one time quantum. |alternative_service2| should no longer
902   // be broken.
903   test_task_runner_->FastForwardBy(base::Seconds(1));
904 
905   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
906   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
907   EXPECT_EQ(1u, expired_alt_svcs_.size());
908   EXPECT_EQ(alternative_service2.alternative_service,
909             expired_alt_svcs_[0].alternative_service);
910   EXPECT_EQ(alternative_service2.network_anonymization_key,
911             expired_alt_svcs_[0].network_anonymization_key);
912 
913   // Advance time until one time quantum before |alternative_service1|'s
914   // brokenness expires
915   test_task_runner_->FastForwardBy(base::Minutes(40) - base::Minutes(5) -
916                                    base::Seconds(1));
917 
918   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
919   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
920   EXPECT_EQ(1u, expired_alt_svcs_.size());
921   EXPECT_EQ(alternative_service2.alternative_service,
922             expired_alt_svcs_[0].alternative_service);
923   EXPECT_EQ(alternative_service2.network_anonymization_key,
924             expired_alt_svcs_[0].network_anonymization_key);
925 
926   // Advance time by one time quantum.  |alternative_service1| should no longer
927   // be broken.
928   test_task_runner_->FastForwardBy(base::Seconds(1));
929 
930   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
931   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
932   EXPECT_EQ(2u, expired_alt_svcs_.size());
933   EXPECT_EQ(alternative_service2.alternative_service,
934             expired_alt_svcs_[0].alternative_service);
935   EXPECT_EQ(alternative_service2.network_anonymization_key,
936             expired_alt_svcs_[0].network_anonymization_key);
937   EXPECT_EQ(alternative_service1.alternative_service,
938             expired_alt_svcs_[1].alternative_service);
939   EXPECT_EQ(alternative_service1.network_anonymization_key,
940             expired_alt_svcs_[1].network_anonymization_key);
941 }
942 
TEST_F(BrokenAlternativeServicesTest,SetBrokenAlternativeServices)943 TEST_F(BrokenAlternativeServicesTest, SetBrokenAlternativeServices) {
944   BrokenAlternativeService alternative_service1(
945       AlternativeService(kProtoQUIC, "foo1", 443), NetworkAnonymizationKey(),
946       true /* use_network_anonymization_key */);
947   BrokenAlternativeService alternative_service2(
948       AlternativeService(kProtoQUIC, "foo2", 443), NetworkAnonymizationKey(),
949       true /* use_network_anonymization_key */);
950 
951   base::TimeDelta delay1 = base::Minutes(1);
952 
953   std::unique_ptr<BrokenAlternativeServiceList> broken_list =
954       std::make_unique<BrokenAlternativeServiceList>();
955   broken_list->push_back(
956       {alternative_service1, broken_services_clock_->NowTicks() + delay1});
957 
958   std::unique_ptr<RecentlyBrokenAlternativeServices> recently_broken_map =
959       std::make_unique<RecentlyBrokenAlternativeServices>(10);
960   recently_broken_map->Put(alternative_service1, 1);
961   recently_broken_map->Put(alternative_service2, 2);
962 
963   broken_services_.SetBrokenAndRecentlyBrokenAlternativeServices(
964       std::move(broken_list), std::move(recently_broken_map));
965 
966   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
967   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
968 
969   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
970   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
971 
972   // Make sure |alternative_service1| expires after the delay in |broken_list|.
973   test_task_runner_->FastForwardBy(delay1 - base::Seconds(1));
974   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
975 
976   test_task_runner_->FastForwardBy(base::Seconds(1));
977   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
978 
979   // Make sure the broken counts in |recently_broken_map| translate to the
980   // correct expiration delays if the alternative services are marked broken.
981   broken_services_.MarkBroken(alternative_service2);
982   broken_services_.MarkBroken(alternative_service1);
983 
984   test_task_runner_->FastForwardBy(base::Minutes(10) - base::Seconds(1));
985   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
986   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
987 
988   test_task_runner_->FastForwardBy(base::Seconds(1));
989   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
990   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
991 
992   test_task_runner_->FastForwardBy(base::Minutes(20) - base::Minutes(10) -
993                                    base::Seconds(1));
994   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
995   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
996 
997   test_task_runner_->FastForwardBy(base::Seconds(1));
998   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
999   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
1000 }
1001 
TEST_F(BrokenAlternativeServicesTest,SetBrokenAlternativeServicesWithExisting)1002 TEST_F(BrokenAlternativeServicesTest,
1003        SetBrokenAlternativeServicesWithExisting) {
1004   BrokenAlternativeService alternative_service1(
1005       AlternativeService(kProtoQUIC, "foo1", 443), NetworkAnonymizationKey(),
1006       true /* use_network_anonymization_key */);
1007   BrokenAlternativeService alternative_service2(
1008       AlternativeService(kProtoQUIC, "foo2", 443), network_anonymization_key1_,
1009       true /* use_network_anonymization_key */);
1010   BrokenAlternativeService alternative_service3(
1011       AlternativeService(kProtoQUIC, "foo3", 443), network_anonymization_key2_,
1012       true /* use_network_anonymization_key */);
1013 
1014   std::unique_ptr<BrokenAlternativeServiceList> broken_list =
1015       std::make_unique<BrokenAlternativeServiceList>();
1016   broken_list->push_back(
1017       {alternative_service1,
1018        broken_services_clock_->NowTicks() + base::Minutes(3)});
1019   broken_list->push_back(
1020       {alternative_service3,
1021        broken_services_clock_->NowTicks() + base::Minutes(1)});
1022 
1023   std::unique_ptr<RecentlyBrokenAlternativeServices> recently_broken_map =
1024       std::make_unique<RecentlyBrokenAlternativeServices>(10);
1025   recently_broken_map->Put(alternative_service1, 1);
1026   recently_broken_map->Put(alternative_service3, 1);
1027 
1028   broken_services_.MarkBroken(alternative_service1);
1029   broken_services_.MarkBroken(alternative_service2);
1030 
1031   // At this point, |alternative_service1| and |alternative_service2| are marked
1032   // broken and should expire in 5 minutes.
1033   // Adding |broken_list| should overwrite |alternative_service1|'s expiration
1034   // time to 3 minutes, and additionally mark |alternative_service3|
1035   // broken with an expiration time of 1 minute.
1036   broken_services_.SetBrokenAndRecentlyBrokenAlternativeServices(
1037       std::move(broken_list), std::move(recently_broken_map));
1038 
1039   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1040   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
1041   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
1042 
1043   // Make sure |alternative_service3|'s brokenness expires in 1 minute.
1044   test_task_runner_->FastForwardBy(base::Minutes(1) - base::Seconds(1));
1045   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1046   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
1047   EXPECT_TRUE(broken_services_.IsBroken(alternative_service3));
1048 
1049   test_task_runner_->FastForwardBy(base::Seconds(1));
1050   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1051   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
1052   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
1053 
1054   // Make sure |alternative_service1|'s brokenness expires in 2 more minutes.
1055   test_task_runner_->FastForwardBy(base::Minutes(2) - base::Seconds(1));
1056   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1057   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
1058   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
1059 
1060   test_task_runner_->FastForwardBy(base::Seconds(1));
1061   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
1062   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
1063   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
1064 
1065   // Make sure |alternative_service2|'s brokenness expires in 2 more minutes.
1066   test_task_runner_->FastForwardBy(base::Minutes(2) - base::Seconds(1));
1067   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
1068   EXPECT_TRUE(broken_services_.IsBroken(alternative_service2));
1069   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
1070 
1071   test_task_runner_->FastForwardBy(base::Seconds(1));
1072   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
1073   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
1074   EXPECT_FALSE(broken_services_.IsBroken(alternative_service3));
1075 
1076   // Make sure recently broken alternative services are in most-recently-used
1077   // order. SetBrokenAndRecentlyBrokenAlternativeServices() will add
1078   // entries in |recently_broken_map| (that aren't already marked recently
1079   // broken in |broken_services_|) to the back of |broken_services_|'s
1080   // recency list; in this case, only |alternative_service3| is added as
1081   // recently broken.
1082   auto it = broken_services_.recently_broken_alternative_services().begin();
1083   EXPECT_EQ(alternative_service2.alternative_service,
1084             it->first.alternative_service);
1085   EXPECT_EQ(alternative_service2.network_anonymization_key,
1086             it->first.network_anonymization_key);
1087   ++it;
1088   EXPECT_EQ(alternative_service1.alternative_service,
1089             it->first.alternative_service);
1090   EXPECT_EQ(alternative_service1.network_anonymization_key,
1091             it->first.network_anonymization_key);
1092   ++it;
1093   EXPECT_EQ(alternative_service3.alternative_service,
1094             it->first.alternative_service);
1095   EXPECT_EQ(alternative_service3.network_anonymization_key,
1096             it->first.network_anonymization_key);
1097 }
1098 
TEST_F(BrokenAlternativeServicesTest,ScheduleExpireTaskAfterExpire)1099 TEST_F(BrokenAlternativeServicesTest, ScheduleExpireTaskAfterExpire) {
1100   // This test will check that when a broken alt svc expires, an expiration task
1101   // is scheduled for the next broken alt svc in the expiration queue.
1102 
1103   BrokenAlternativeService alternative_service1(
1104       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
1105       true /* use_network_anonymization_key */);
1106   BrokenAlternativeService alternative_service2(
1107       AlternativeService(kProtoQUIC, "bar", 443), NetworkAnonymizationKey(),
1108       true /* use_network_anonymization_key */);
1109 
1110   // Mark |alternative_service1| broken and let brokenness expire. This will
1111   // increase its expiration delay the next time it's marked broken.
1112   broken_services_.MarkBroken(alternative_service1);
1113   test_task_runner_->FastForwardBy(base::Minutes(5));
1114   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
1115   EXPECT_FALSE(test_task_runner_->HasPendingTask());
1116 
1117   // Mark |alternative_service1| and |alternative_service2| broken and
1118   // let |alternative_service2|'s brokenness expire.
1119   broken_services_.MarkBroken(alternative_service1);
1120   broken_services_.MarkBroken(alternative_service2);
1121 
1122   test_task_runner_->FastForwardBy(base::Minutes(5));
1123   EXPECT_FALSE(broken_services_.IsBroken(alternative_service2));
1124   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1125 
1126   // Make sure an expiration task has been scheduled for expiring the brokenness
1127   // of |alternative_service1|.
1128   EXPECT_TRUE(test_task_runner_->HasPendingTask());
1129 }
1130 
TEST_F(BrokenAlternativeServicesTest,Clear)1131 TEST_F(BrokenAlternativeServicesTest, Clear) {
1132   BrokenAlternativeService alternative_service1(
1133       AlternativeService(kProtoQUIC, "foo", 443), NetworkAnonymizationKey(),
1134       true /* use_network_anonymization_key */);
1135   BrokenAlternativeService alternative_service2(
1136       AlternativeService(kProtoQUIC, "bar", 443), NetworkAnonymizationKey(),
1137       true /* use_network_anonymization_key */);
1138 
1139   broken_services_.MarkBroken(alternative_service1);
1140   broken_services_.MarkRecentlyBroken(alternative_service2);
1141 
1142   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1143   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
1144   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
1145 
1146   broken_services_.Clear();
1147 
1148   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
1149   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
1150   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
1151 
1152   std::unique_ptr<BrokenAlternativeServiceList> broken_list =
1153       std::make_unique<BrokenAlternativeServiceList>();
1154   broken_list->push_back(
1155       {alternative_service1,
1156        broken_services_clock_->NowTicks() + base::Minutes(1)});
1157 
1158   std::unique_ptr<RecentlyBrokenAlternativeServices> recently_broken_map =
1159       std::make_unique<RecentlyBrokenAlternativeServices>(10);
1160   recently_broken_map->Put(alternative_service2, 2);
1161 
1162   broken_services_.SetBrokenAndRecentlyBrokenAlternativeServices(
1163       std::move(broken_list), std::move(recently_broken_map));
1164 
1165   EXPECT_TRUE(broken_services_.IsBroken(alternative_service1));
1166   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service1));
1167   EXPECT_TRUE(broken_services_.WasRecentlyBroken(alternative_service2));
1168 
1169   broken_services_.Clear();
1170 
1171   EXPECT_FALSE(broken_services_.IsBroken(alternative_service1));
1172   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service1));
1173   EXPECT_FALSE(broken_services_.WasRecentlyBroken(alternative_service2));
1174 }
1175 
1176 }  // namespace
1177 
1178 }  // namespace net
1179