Fix and refactor HttpServerPropertiesImpl's alternative services brokenness expiration behavior

net/http/http_broken_alternative_services_manager_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/http_broken_alternative_services_manager.h"
+
+#include <vector>
+
+#include "base/test/test_mock_time_task_runner.h"
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+class TestClock : public HttpBrokenAlternativeServicesManager::Clock {
+ public:
+  TestClock() : now_(base::TimeTicks::Now()) {}
+  ~TestClock() override {}
+
+  base::TimeTicks Now() const override { return now_; }
+
+  void Set(base::TimeTicks now) { now_ = now; }
+  void Advance(base::TimeDelta delta) { now_ += delta; }
+
+ private:
+  base::TimeTicks now_;
+};
+
+class HttpBrokenAlternativeServicesManagerTest
+    : public HttpBrokenAlternativeServicesManager::Delegate,
+      public ::testing::Test {
+ public:
+  HttpBrokenAlternativeServicesManagerTest()
+      : manager_(this, &test_clock_),
+        test_task_runner_(new base::TestMockTimeTaskRunner()) {}
+
+  // HttpBrokenAlternativeServicesManager::Delegate implementation
+  void OnExpireBrokenAlternativeService(
+      const AlternativeService& expired_alternative_service) override {
+    expired_alt_svcs.push_back(expired_alternative_service);
+  }
+
+  ::testing::AssertionResult MarkAlternativeServiceBrokenAndLetExpireNTimes(
+      const AlternativeService& alternative_service,
+      int num_times) {
+    for (int i = 0; i < num_times; ++i) {
+      {
+        base::TestMockTimeTaskRunner::ScopedContext scoped_context(
+            test_task_runner_);
+        manager_.MarkAlternativeServiceBroken(alternative_service);
+      }
+      if (!manager_.IsAlternativeServiceBroken(alternative_service)) {
+        return ::testing::AssertionFailure() << "Alt svc not showing as broken "
+                                             << "after being marked broken.";
+      }
+
+      // |manager_| should have posted task to expire the brokenness of
+      // |alternative_service|.
+      int pending_task_count = test_task_runner_->GetPendingTaskCount();
+      if (pending_task_count != 1u) {
+        return ::testing::AssertionFailure()
+               << "Test task runner has " << pending_task_count
+               << " pending tasks instead of 1 after marking "
+               << "alternative service broken.";
+      }
+
+      // Advance time by just enough so that |alternative_service|'s brokenness
+      // expires.
+      base::TimeDelta delta = HttpBrokenAlternativeServicesManager::
+          ComputeBrokenAltSvcExpirationDelayForTest(i);
+      test_clock_.Advance(delta);
+      test_task_runner_->FastForwardBy(delta);
+
+      // Ensure |alternative_service| brokenness has expired
+      if (manager_.IsAlternativeServiceBroken(alternative_service)) {
+        return ::testing::AssertionFailure() << "Alt svc showing as broken "
+                                             << " after being confirmed.";
+      }
+    }
+    return ::testing::AssertionSuccess();
+  }
+
+  TestClock test_clock_;
+  std::vector<AlternativeService> expired_alt_svcs;
+  HttpBrokenAlternativeServicesManager manager_;
+
+  scoped_refptr<base::TestMockTimeTaskRunner> test_task_runner_;
+};
+
+TEST_F(HttpBrokenAlternativeServicesManagerTest, MarkBroken) {
+  const AlternativeService alternative_service1(kProtoHTTP2, "foo", 443);
+  const AlternativeService alternative_service2(kProtoHTTP2, "foo", 1234);
+
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  manager_.MarkAlternativeServiceBroken(alternative_service1);
+
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  manager_.MarkAlternativeServiceBroken(alternative_service2);
+
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  manager_.ConfirmAlternativeService(alternative_service1);
+
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  manager_.ConfirmAlternativeService(alternative_service2);
+
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service2));
+}
+
+TEST_F(HttpBrokenAlternativeServicesManagerTest, MarkRecentlyBroken) {
+  const AlternativeService alternative_service(kProtoHTTP2, "foo", 443);
+
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service));
+  EXPECT_FALSE(
+      manager_.WasAlternativeServiceRecentlyBroken(alternative_service));
+
+  manager_.MarkAlternativeServiceRecentlyBroken(alternative_service);
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service));
+  EXPECT_TRUE(
+      manager_.WasAlternativeServiceRecentlyBroken(alternative_service));
+
+  manager_.ConfirmAlternativeService(alternative_service);
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service));
+  EXPECT_FALSE(
+      manager_.WasAlternativeServiceRecentlyBroken(alternative_service));
+}
+
+TEST_F(HttpBrokenAlternativeServicesManagerTest,
+       ExpireBrokenAlternateProtoclMappings) {
+  AlternativeService alternative_service(kProtoQUIC, "foo", 443);
+
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service));
+  EXPECT_FALSE(
+      manager_.WasAlternativeServiceRecentlyBroken(alternative_service));
+
+  EXPECT_TRUE(
+      MarkAlternativeServiceBrokenAndLetExpireNTimes(alternative_service, 1));
+}
+
+TEST_F(HttpBrokenAlternativeServicesManagerTest, RemoveExpiredBrokenAltSvc) {
+  // This test will mark broken an alternative service A that has already been
+  // marked broken many times, then immediately mark another alternative service
+  // B as broken for the first time. Because A's been marked broken many times
+  // already, its brokenness will be scheduled to expire much further in the
+  // future than B, even though it was marked broken before B. This test makes
+  // sure that even though A was marked broken before B, B's brokenness should
+  // expire before A.
+
+  // This test only makes sense if HttpServerPropertiesImpl's expiration delay
+  // for a broken AlternativeService is an increasing function of how many times
+  // that AlternativeService has been marked broken already.
+  DCHECK(HttpBrokenAlternativeServicesManager::
+             ComputeBrokenAltSvcExpirationDelayForTest(3) >
+         HttpBrokenAlternativeServicesManager::
+             ComputeBrokenAltSvcExpirationDelayForTest(0));
+
+  AlternativeService alternative_service1(kProtoQUIC, "foo", 443);
+  AlternativeService alternative_service2(kProtoQUIC, "bar", 443);
+
+  EXPECT_TRUE(
+      MarkAlternativeServiceBrokenAndLetExpireNTimes(alternative_service1, 3));
+
+  {
+    base::TestMockTimeTaskRunner::ScopedContext scoped_context(
+        test_task_runner_);
+
+    manager_.MarkAlternativeServiceBroken(alternative_service1);
+    manager_.MarkAlternativeServiceBroken(alternative_service2);
+  }
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  // Advance time until one time quantum before |alternative_service2|'s
+  // brokenness expires.
+  base::TimeDelta delta = HttpBrokenAlternativeServicesManager::
+                              ComputeBrokenAltSvcExpirationDelayForTest(0) -
+                          base::TimeDelta::FromInternalValue(1);
+  test_clock_.Advance(delta);
+  test_task_runner_->FastForwardBy(delta);
+
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  // Advance time by one time quantum. |alternative_service2| should no longer
+  // be broken.
+  delta = base::TimeDelta::FromInternalValue(1);
+  test_clock_.Advance(delta);
+  test_task_runner_->FastForwardBy(delta);
+
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  // Advance time until one time quantum before |alternative_service1|'s
+  // brokenness expires
+  delta = HttpBrokenAlternativeServicesManager::
+              ComputeBrokenAltSvcExpirationDelayForTest(3) -
+          HttpBrokenAlternativeServicesManager::
+              ComputeBrokenAltSvcExpirationDelayForTest(0) -
+          base::TimeDelta::FromInternalValue(1);
+  test_clock_.Advance(delta);
+  test_task_runner_->FastForwardBy(delta);
+
+  EXPECT_TRUE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service2));
+
+  // Advance time by one time quantum.  |alternative_service1| should no longer
+  // be broken.
+  delta = base::TimeDelta::FromInternalValue(1);
+  test_clock_.Advance(delta);
+  test_task_runner_->FastForwardBy(delta);
+
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service1));
+  EXPECT_FALSE(manager_.IsAlternativeServiceBroken(alternative_service2));
+}
+
+}  // namespace
+
+}  // namespace net