Refactor net::BackoffEntry to not require subclassing

net/url_request/url_request_throttler_simulation_unittest.cc

 // 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.
 
 // The tests in this file attempt to verify the following through simulation:
 // a) That a server experiencing overload will actually benefit from the
 //    anti-DDoS throttling logic, i.e. that its traffic spike will subside
 //    and be distributed over a longer period of time;
 // b) That "well-behaved" clients of a server under DDoS attack actually
 //    benefit from the anti-DDoS throttling logic; and
@@ skipping 285 matching lines @@
   scoped_ptr<URLRequest> mock_request_;
 
   DISALLOW_COPY_AND_ASSIGN(Server);
 };
 
 // Mock throttler entry used by Requester class.
 class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public:
   explicit MockURLRequestThrottlerEntry(URLRequestThrottlerManager* manager)
       : URLRequestThrottlerEntry(manager, std::string()),
-        mock_backoff_entry_(&backoff_policy_) {}
+        backoff_entry_(&backoff_policy_, &fake_clock_) {}
 
   const BackoffEntry* GetBackoffEntry() const override {
-    return &mock_backoff_entry_;
+    return &backoff_entry_;
   }
 
-  BackoffEntry* GetBackoffEntry() override { return &mock_backoff_entry_; }
+  BackoffEntry* GetBackoffEntry() override { return &backoff_entry_; }
 
-  TimeTicks ImplGetTimeNow() const override { return fake_now_; }
+  TimeTicks ImplGetTimeNow() const override { return fake_clock_.NowTicks(); }
 
   void SetFakeNow(const TimeTicks& fake_time) {
-    fake_now_ = fake_time;
-    mock_backoff_entry_.set_fake_now(fake_time);
-  }
-
-  TimeTicks fake_now() const {
-    return fake_now_;
+    fake_clock_.set_now(fake_time);
   }
 
  protected:
   ~MockURLRequestThrottlerEntry() override {}
 
  private:
-  TimeTicks fake_now_;
-  MockBackoffEntry mock_backoff_entry_;
+  mutable TestTickClock fake_clock_;
+  BackoffEntry backoff_entry_;
 };
 
 // Registry of results for a class of |Requester| objects (e.g. attackers vs.
 // regular clients).
 class RequesterResults {
  public:
   RequesterResults()
       : num_attempts_(0), num_successful_(0), num_failed_(0), num_blocked_(0) {
   }
 
@@ skipping 78 matching lines @@
   void PerformAction() override {
     TimeDelta effective_delay = time_between_requests_;
     TimeDelta current_jitter = TimeDelta::FromMilliseconds(
         request_jitter_.InMilliseconds() * base::RandDouble());
     if (base::RandInt(0, 1)) {
       effective_delay -= current_jitter;
     } else {
       effective_delay += current_jitter;
     }
 
-    if (throttler_entry_->fake_now() - time_of_last_attempt_ >
+    if (throttler_entry_->ImplGetTimeNow() - time_of_last_attempt_ >
         effective_delay) {
       if (!throttler_entry_->ShouldRejectRequest(
               server_->mock_request(),
               server_->context().network_delegate())) {
         int status_code = server_->HandleRequest();
         MockURLRequestThrottlerHeaderAdapter response_headers(status_code);
         throttler_entry_->UpdateWithResponse(std::string(), &response_headers);
 
         if (status_code == 200) {
           if (results_)
             results_->AddSuccess();
 
           if (last_attempt_was_failure_) {
             last_downtime_duration_ =
-                throttler_entry_->fake_now() - time_of_last_success_;
+                throttler_entry_->ImplGetTimeNow() - time_of_last_success_;
           }
 
-          time_of_last_success_ = throttler_entry_->fake_now();
+          time_of_last_success_ = throttler_entry_->ImplGetTimeNow();
           last_attempt_was_failure_ = false;
         } else {
           if (results_)
             results_->AddFailure();
           last_attempt_was_failure_ = true;
         }
       } else {
         if (results_)
           results_->AddBlocked();
         last_attempt_was_failure_ = true;
       }
 
-      time_of_last_attempt_ = throttler_entry_->fake_now();
+      time_of_last_attempt_ = throttler_entry_->ImplGetTimeNow();
     }
   }
 
   // Adds a delay until the first request, equal to a uniformly distributed
   // value between now and now + max_delay.
   void SetStartupJitter(const TimeDelta& max_delay) {
     int delay_ms = base::RandInt(0, max_delay.InMilliseconds());
     time_of_last_attempt_ = TimeTicks() +
         TimeDelta::FromMilliseconds(delay_ms) - time_between_requests_;
   }
@@ skipping 277 matching lines @@
     trials[i].PrintTrialDescription();
     trials[i].stats.ReportTrialResult(increase_ratio);
   }
 
   VerboseOut("Average increase ratio was %.4f\n", average_increase_ratio);
   VerboseOut("Maximum increase ratio was %.4f\n", max_increase_ratio);
 }
 
 }  // namespace
 }  // namespace net