BackoffEntry: Add the option to always use a delay.

net/base/backoff_entry_unittest.cc

 // Copyright (c) 2011 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/base/backoff_entry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 using base::TimeDelta;
 using base::TimeTicks;
 using net::BackoffEntry;
 
-BackoffEntry::Policy base_policy = { 0, 1000, 2.0, 0.0, 20000, 2000 };
+BackoffEntry::Policy base_policy = { 0, 1000, 2.0, 0.0, 20000, 2000, false };
 
 class TestBackoffEntry : public BackoffEntry {
  public:
   explicit TestBackoffEntry(const Policy* const policy)
       : BackoffEntry(policy),
         now_(TimeTicks()) {
     // Work around initialization in constructor not picking up
     // fake time.
     SetCustomReleaseTime(TimeTicks());
   }
@@ skipping 10 matching lines @@
 
  private:
   TimeTicks now_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBackoffEntry);
 };
 
 TEST(BackoffEntryTest, BaseTest) {
   TestBackoffEntry entry(&base_policy);
   EXPECT_FALSE(entry.ShouldRejectRequest());
+  EXPECT_EQ(TimeDelta(), entry.GetTimeUntilRelease());
 
   entry.InformOfRequest(false);
   EXPECT_TRUE(entry.ShouldRejectRequest());
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease());
 }
 
 TEST(BackoffEntryTest, CanDiscardNeverExpires) {
   BackoffEntry::Policy never_expires_policy = base_policy;
   never_expires_policy.entry_lifetime_ms = -1;
   TestBackoffEntry never_expires(&never_expires_policy);
   EXPECT_FALSE(never_expires.CanDiscard());
   never_expires.set_now(TimeTicks() + TimeDelta::FromDays(100));
   EXPECT_FALSE(never_expires.CanDiscard());
 }
@@ skipping 18 matching lines @@
   // Test the final case (no errors, dependent only on specified lifetime).
   entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(
       base_policy.entry_lifetime_ms - 1));
   entry.InformOfRequest(true);
   EXPECT_FALSE(entry.CanDiscard());
   entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(
       base_policy.entry_lifetime_ms));
   EXPECT_TRUE(entry.CanDiscard());
 }
 
+TEST(BackoffEntryTest, CanDiscardAlwaysDelay) {
+  BackoffEntry::Policy always_delay_policy = base_policy;
+  always_delay_policy.always_use_initial_delay = true;
+  always_delay_policy.entry_lifetime_ms = 0;
+
+  TestBackoffEntry entry(&always_delay_policy);
+
+  // Because lifetime is non-zero, we shouldn't be able to discard yet.
+  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(2000));
+  EXPECT_TRUE(entry.CanDiscard());
+
+  // Even with no failures, we wait until the delay before we allow discard.
+  entry.InformOfRequest(true);
+  EXPECT_FALSE(entry.CanDiscard());
+
+  // Wait until the delay expires, and we can discard the entry again.
+  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(1000));
+  EXPECT_TRUE(entry.CanDiscard());
+}
+
 TEST(BackoffEntryTest, CanDiscardNotStored) {
   BackoffEntry::Policy no_store_policy = base_policy;
   no_store_policy.entry_lifetime_ms = 0;
   TestBackoffEntry not_stored(&no_store_policy);
   EXPECT_TRUE(not_stored.CanDiscard());
 }
 
 TEST(BackoffEntryTest, ShouldIgnoreFirstTwo) {
   BackoffEntry::Policy lenient_policy = base_policy;
   lenient_policy.num_errors_to_ignore = 2;
 
   BackoffEntry entry(&lenient_policy);
+
   entry.InformOfRequest(false);
   EXPECT_FALSE(entry.ShouldRejectRequest());
+
   entry.InformOfRequest(false);
   EXPECT_FALSE(entry.ShouldRejectRequest());
+
   entry.InformOfRequest(false);
   EXPECT_TRUE(entry.ShouldRejectRequest());
 }
 
 TEST(BackoffEntryTest, ReleaseTimeCalculation) {
   TestBackoffEntry entry(&base_policy);
 
   // With zero errors, should return "now".
   TimeTicks result = entry.GetReleaseTime();
   EXPECT_EQ(entry.ImplGetTimeNow(), result);
 
   // 1 error.
   entry.InformOfRequest(false);
   result = entry.GetReleaseTime();
   EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(1000), result);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease());
 
   // 2 errors.
   entry.InformOfRequest(false);
   result = entry.GetReleaseTime();
   EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(2000), result);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease());
 
   // 3 errors.
   entry.InformOfRequest(false);
   result = entry.GetReleaseTime();
   EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000), result);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(4000), entry.GetTimeUntilRelease());
 
   // 6 errors (to check it doesn't pass maximum).
   entry.InformOfRequest(false);
   entry.InformOfRequest(false);
   entry.InformOfRequest(false);
   result = entry.GetReleaseTime();
   EXPECT_EQ(
       entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(20000), result);
 }
 
+TEST(BackoffEntryTest, ReleaseTimeCalculationAlwaysDelay) {
+  BackoffEntry::Policy always_delay_policy = base_policy;
+  always_delay_policy.always_use_initial_delay = true;
+  always_delay_policy.num_errors_to_ignore = 2;
+
+  TestBackoffEntry entry(&always_delay_policy);
+
+  // With previous requests, should return "now".
+  TimeTicks result = entry.GetReleaseTime();
+  EXPECT_EQ(TimeDelta(), entry.GetTimeUntilRelease());
+
+  // 1 error.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease());
+
+  // 2 errors.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease());
+
+  // 3 errors, exponential backoff starts.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease());
+
+  // 4 errors.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(4000), entry.GetTimeUntilRelease());
+
+  // 8 errors (to check it doesn't pass maximum).
+  entry.InformOfRequest(false);
+  entry.InformOfRequest(false);
+  entry.InformOfRequest(false);
+  entry.InformOfRequest(false);
+  result = entry.GetReleaseTime();
+  EXPECT_EQ(TimeDelta::FromMilliseconds(20000), entry.GetTimeUntilRelease());
+}
+
 TEST(BackoffEntryTest, ReleaseTimeCalculationWithJitter) {
   for (int i = 0; i < 10; ++i) {
     BackoffEntry::Policy jittery_policy = base_policy;
     jittery_policy.jitter_factor = 0.2;
 
     TestBackoffEntry entry(&jittery_policy);
 
     entry.InformOfRequest(false);
     entry.InformOfRequest(false);
     entry.InformOfRequest(false);
@@ skipping 18 matching lines @@
   entry.set_now(release_time - TimeDelta::FromMilliseconds(200));
   entry.InformOfRequest(true);
   EXPECT_EQ(release_time, entry.GetReleaseTime());
 
   // Failure, failure count 1.
   entry.InformOfRequest(false);
   EXPECT_EQ(release_time + TimeDelta::FromMilliseconds(800),
             entry.GetReleaseTime());
 }
 
+TEST(BackoffEntryTest, FailureThenSuccessAlwaysDelay) {
+  BackoffEntry::Policy always_delay_policy = base_policy;
+  always_delay_policy.always_use_initial_delay = true;
+  always_delay_policy.num_errors_to_ignore = 1;
+
+  TestBackoffEntry entry(&always_delay_policy);
+
+  // Failure count 1.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease());
+
+  // Failure count 2.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease());
+  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(2000));
+
+  // Success.  We should go back to the original delay.
+  entry.InformOfRequest(true);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease());
+
+  // Failure count reaches 2 again.  We should increase the delay once more.
+  entry.InformOfRequest(false);
+  EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease());
+  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(2000));
+}
+
 TEST(BackoffEntryTest, RetainCustomHorizon) {
   TestBackoffEntry custom(&base_policy);
   TimeTicks custom_horizon = TimeTicks() + TimeDelta::FromDays(3);
   custom.SetCustomReleaseTime(custom_horizon);
   custom.InformOfRequest(false);
   custom.InformOfRequest(true);
   custom.set_now(TimeTicks() + TimeDelta::FromDays(2));
   custom.InformOfRequest(false);
   custom.InformOfRequest(true);
   EXPECT_EQ(custom_horizon, custom.GetReleaseTime());
@@ skipping 12 matching lines @@
   BackoffEntry::Policy lenient_policy = base_policy;
   lenient_policy.num_errors_to_ignore = 1;
   TestBackoffEntry custom(&lenient_policy);
   TimeTicks custom_horizon = TimeTicks() + TimeDelta::FromDays(3);
   custom.SetCustomReleaseTime(custom_horizon);
   custom.InformOfRequest(false);  // This must not reset the horizon.
   EXPECT_EQ(custom_horizon, custom.GetReleaseTime());
 }
 
 }  // namespace