Remove //net (except for Android test stuff) and sdch

net/base/backoff_entry_unittest.cc

Index: net/base/backoff_entry_unittest.cc
diff --git a/net/base/backoff_entry_unittest.cc b/net/base/backoff_entry_unittest.cc
deleted file mode 100644
index 89ec2c4d2f160c4551fc6fa7a8672528017925a1..0000000000000000000000000000000000000000
--- a/net/base/backoff_entry_unittest.cc
+++ /dev/null
@@ -1,312 +0,0 @@
-// Copyright (c) 2012 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, 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());
-  }
-
-  ~TestBackoffEntry() override {}
-
-  TimeTicks ImplGetTimeNow() const override { return now_; }
-
-  void set_now(const TimeTicks& now) {
-    now_ = now;
-  }
-
- 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());
-}
-
-TEST(BackoffEntryTest, CanDiscard) {
-  TestBackoffEntry entry(&base_policy);
-  // Because lifetime is non-zero, we shouldn't be able to discard yet.
-  EXPECT_FALSE(entry.CanDiscard());
-
-  // Test the "being used" case.
-  entry.InformOfRequest(false);
-  EXPECT_FALSE(entry.CanDiscard());
-
-  // Test the case where there are errors but we can time out.
-  entry.set_now(
-      entry.GetReleaseTime() + TimeDelta::FromMilliseconds(1));
-  EXPECT_FALSE(entry.CanDiscard());
-  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(
-      base_policy.maximum_backoff_ms + 1));
-  EXPECT_TRUE(entry.CanDiscard());
-
-  // 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);
-    TimeTicks result = entry.GetReleaseTime();
-    EXPECT_LE(
-        entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(3200), result);
-    EXPECT_GE(
-        entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000), result);
-  }
-}
-
-TEST(BackoffEntryTest, FailureThenSuccess) {
-  TestBackoffEntry entry(&base_policy);
-
-  // Failure count 1, establishes horizon.
-  entry.InformOfRequest(false);
-  TimeTicks release_time = entry.GetReleaseTime();
-  EXPECT_EQ(TimeTicks() + TimeDelta::FromMilliseconds(1000), release_time);
-
-  // Success, failure count 0, should not advance past
-  // the horizon that was already set.
-  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());
-
-  // Now check that once we are at or past the custom horizon,
-  // we get normal behavior.
-  custom.set_now(TimeTicks() + TimeDelta::FromDays(3));
-  custom.InformOfRequest(false);
-  EXPECT_EQ(
-      TimeTicks() + TimeDelta::FromDays(3) + TimeDelta::FromMilliseconds(1000),
-      custom.GetReleaseTime());
-}
-
-TEST(BackoffEntryTest, RetainCustomHorizonWhenInitialErrorsIgnored) {
-  // Regression test for a bug discovered during code review.
-  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());
-}
-
-TEST(BackoffEntryTest, OverflowProtection) {
-  BackoffEntry::Policy large_multiply_policy = base_policy;
-  large_multiply_policy.multiply_factor = 256;
-  TestBackoffEntry custom(&large_multiply_policy);
-
-  // Trigger enough failures such that more than 11 bits of exponent are used
-  // to represent the exponential backoff intermediate values. Given a multiply
-  // factor of 256 (2^8), 129 iterations is enough: 2^(8*(129-1)) = 2^1024.
-  for (int i = 0; i < 129; ++i) {
-     custom.set_now(custom.ImplGetTimeNow() + custom.GetTimeUntilRelease());
-     custom.InformOfRequest(false);
-     ASSERT_TRUE(custom.ShouldRejectRequest());
-  }
-
-  // Max delay should still be respected.
-  EXPECT_EQ(20000, custom.GetTimeUntilRelease().InMilliseconds());
-}
-
-}  // namespace