Persist broken and recently-broken alt-svcs to prefs in HttpServerPropertiesManager

net/http/broken_alternative_services_unittest.cc

 // Copyright (c) 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/broken_alternative_services.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/time/tick_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class BrokenAlternativeServicesTest
     : public BrokenAlternativeServices::Delegate,
       public ::testing::Test {
  public:
   BrokenAlternativeServicesTest()
       : test_task_runner_(new base::TestMockTimeTaskRunner()),
         test_task_runner_context_(test_task_runner_),
         broken_services_clock_(test_task_runner_->GetMockTickClock()),
-        broken_services_(this, broken_services_clock_.get()) {}
+        broken_services_(this) {
+    broken_services_.SetTickClockForTesting(broken_services_clock_.get());
+  }
 
   // BrokenAlternativeServices::Delegate implementation
   void OnExpireBrokenAlternativeService(
       const AlternativeService& expired_alternative_service) override {
     expired_alt_svcs_.push_back(expired_alternative_service);
   }
 
   // All tests will run inside the scope of |test_task_runner_context_|, which
   // means any task posted to the main message loop will run on
   // |test_task_runner_|.
@@ skipping 364 matching lines @@
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
   EXPECT_FALSE(
       broken_services_.IsAlternativeServiceBroken(alternative_service2));
 }
 
 TEST_F(BrokenAlternativeServicesTest, AddBrokenAlternativeServicesToExisting) {
   AlternativeService alternative_service1(kProtoQUIC, "foo1", 443);
   AlternativeService alternative_service2(kProtoQUIC, "foo2", 443);
   AlternativeService alternative_service3(kProtoQUIC, "foo3", 443);
 
-  base::TimeDelta delay1 = base::TimeDelta::FromMinutes(1);
-  base::TimeDelta delay3 = base::TimeDelta::FromMinutes(3);
-
   std::unique_ptr<BrokenAlternativeServiceList> broken_list =
       base::MakeUnique<BrokenAlternativeServiceList>();
   broken_list->push_back(
-      {alternative_service3, broken_services_clock_->NowTicks() + delay3});
+      {alternative_service3,
+       broken_services_clock_->NowTicks() + base::TimeDelta::FromMinutes(1)});
   broken_list->push_back(
-      {alternative_service1, broken_services_clock_->NowTicks() + delay1});
+      {alternative_service1,
+       broken_services_clock_->NowTicks() + base::TimeDelta::FromMinutes(3)});
 
   std::unique_ptr<RecentlyBrokenAlternativeServices> recently_broken_map =
       base::MakeUnique<RecentlyBrokenAlternativeServices>(
           RecentlyBrokenAlternativeServices::NO_AUTO_EVICT);
   recently_broken_map->Put(alternative_service1, 1);
   recently_broken_map->Put(alternative_service3, 1);
 
   broken_services_.MarkAlternativeServiceBroken(alternative_service1);
   broken_services_.MarkAlternativeServiceBroken(alternative_service2);
 
   // At this point, |alternative_service1| and |alternative_service2| are marked
   // broken and should expire in 5 minutes.
-  // Adding |broken_list| should additionally mark |alternative_service3|
-  // broken and should expire in 3 minute. Even though |broken_list| contains
-  // |alternative_service1|, its expiration time should not change since it was
-  // already marked broken.
+  // Adding |broken_list| should overwrite |alternative_service1|'s expiration
+  // time to 3 minutes, and additionally mark |alternative_service3|
+  // broken with an expiration time of 1 minute.
   broken_services_.AddBrokenAndRecentlyBrokenAlternativeServices(
       std::move(broken_list), std::move(recently_broken_map));
 
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service2));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service3));
 
-  // Make sure |alternative_service3|'s brokenness expires in 3 minutes.
-  test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(3) -
+  // Make sure |alternative_service3|'s brokenness expires in 1 minute.
+  test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(1) -
                                    base::TimeDelta::FromInternalValue(1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service2));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service3));
 
   test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service2));
   EXPECT_FALSE(
       broken_services_.IsAlternativeServiceBroken(alternative_service3));
 
-  // Make sure |alternative_service1| and |alternative_service2|'s brokenness
-  // expire in 2 more minutes.
+  // Make sure |alternative_service1|'s brokenness expires in 2 more minutes.
   test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(2) -
                                    base::TimeDelta::FromInternalValue(1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
   EXPECT_TRUE(
       broken_services_.IsAlternativeServiceBroken(alternative_service2));
   EXPECT_FALSE(
       broken_services_.IsAlternativeServiceBroken(alternative_service3));
 
   test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1));
   EXPECT_FALSE(
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_TRUE(
+      broken_services_.IsAlternativeServiceBroken(alternative_service2));
+  EXPECT_FALSE(
+      broken_services_.IsAlternativeServiceBroken(alternative_service3));
+
+  // Make sure |alternative_service2|'s brokenness expires in 2 more minutes.
+  test_task_runner_->FastForwardBy(base::TimeDelta::FromMinutes(2) -
+                                   base::TimeDelta::FromInternalValue(1));
+  EXPECT_FALSE(
+      broken_services_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_TRUE(
+      broken_services_.IsAlternativeServiceBroken(alternative_service2));
+  EXPECT_FALSE(
+      broken_services_.IsAlternativeServiceBroken(alternative_service3));
+
+  test_task_runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1));
+  EXPECT_FALSE(
+      broken_services_.IsAlternativeServiceBroken(alternative_service1));
   EXPECT_FALSE(
       broken_services_.IsAlternativeServiceBroken(alternative_service2));
   EXPECT_FALSE(
       broken_services_.IsAlternativeServiceBroken(alternative_service3));
 
   // Make sure recently broken alternative services are in most-recently-used
   // order. AddBrokenAndRecentlyBrokenAlternativeServices() will add
   // entries in |recently_broken_map| (that aren't already marked recently
   // broken in |broken_services_|) to the back of |broken_services_|'s
   // recency list; in this case, only |alternative_service3| is added as
@@ skipping 33 matching lines @@
       broken_services_.IsAlternativeServiceBroken(alternative_service1));
 
   // Make sure an expiration task has been scheduled for expiring the brokenness
   // of |alternative_service1|.
   EXPECT_TRUE(test_task_runner_->HasPendingTask());
 }
 
 }  // namespace
 
 }  // namespace net