Refactor net::BackoffEntry to not require subclassing

chrome/browser/captive_portal/captive_portal_service.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.
 
 #include "chrome/browser/captive_portal/captive_portal_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
+#include "base/time/tick_clock.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/captive_portal/captive_portal_types.h"
 #include "content/public/browser/notification_service.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
@@ skipping 108 matching lines @@
 #else
   return false;
 #endif
 }
 
 }  // namespace
 
 CaptivePortalService::TestingState CaptivePortalService::testing_state_ =
     NOT_TESTING;
 
-class CaptivePortalService::RecheckBackoffEntry : public net::BackoffEntry {
+class CaptivePortalService::RecheckTickClock : public base::TickClock {
  public:
-  explicit RecheckBackoffEntry(CaptivePortalService* captive_portal_service)
-      : net::BackoffEntry(
-            &captive_portal_service->recheck_policy().backoff_policy),
-        captive_portal_service_(captive_portal_service) {
+  explicit RecheckTickClock(CaptivePortalService* captive_portal_service)
+      : captive_portal_service_(captive_portal_service) {
+  }
+
+  base::TimeTicks NowTicks() override {
+    return captive_portal_service_->NowTicks();
   }
 
  private:
-  base::TimeTicks ImplGetTimeNow() const override {
-    return captive_portal_service_->GetCurrentTimeTicks();
-  }
-
   CaptivePortalService* captive_portal_service_;
 
-  DISALLOW_COPY_AND_ASSIGN(RecheckBackoffEntry);
+  DISALLOW_COPY_AND_ASSIGN(RecheckTickClock);
 };
 
 CaptivePortalService::RecheckPolicy::RecheckPolicy()
     : initial_backoff_no_portal_ms(600 * 1000),
       initial_backoff_portal_ms(20 * 1000) {
   // Receiving a new Result is considered a success.  All subsequent requests
   // that get the same Result are considered "failures", so a value of N
   // means exponential backoff starts after getting a result N + 2 times:
   // +1 for the initial success, and +1 because N failures are ignored.
   //
@@ skipping 86 matching lines @@
 
 void CaptivePortalService::OnPortalDetectionCompleted(
     const captive_portal::CaptivePortalDetector::Results& results) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(STATE_CHECKING_FOR_PORTAL, state_);
   DCHECK(!TimerRunning());
   DCHECK(enabled_);
 
   CaptivePortalResult result = results.result;
   const base::TimeDelta& retry_after_delta = results.retry_after_delta;
-  base::TimeTicks now = GetCurrentTimeTicks();
+  base::TimeTicks now = NowTicks();
 
   // Record histograms.
   UMA_HISTOGRAM_ENUMERATION("CaptivePortal.DetectResult",
                             GetHistogramEntryForDetectionResult(results),
                             DETECTION_RESULT_COUNT);
 
   // If this isn't the first captive portal result, record stats.
   if (!last_check_time_.is_null()) {
     UMA_HISTOGRAM_LONG_TIMES("CaptivePortal.TimeBetweenChecks",
                              now - last_check_time_);
@@ skipping 35 matching lines @@
 
   OnResult(result, results.landing_url);
 }
 
 void CaptivePortalService::Shutdown() {
   DCHECK(CalledOnValidThread());
   if (enabled_) {
     RecordRepeatHistograms(
         last_detection_result_,
         num_checks_with_same_result_,
-        GetCurrentTimeTicks() - first_check_time_with_same_result_);
+        NowTicks() - first_check_time_with_same_result_);
   }
 }
 
 void CaptivePortalService::OnResult(CaptivePortalResult result,
                                     const GURL& landing_url) {
   DCHECK_EQ(STATE_CHECKING_FOR_PORTAL, state_);
   state_ = STATE_IDLE;
 
   Results results;
   results.previous_result = last_detection_result_;
@@ skipping 11 matching lines @@
   if (!enabled_ || result == captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL) {
     // Use the shorter time when the captive portal service is not enabled, or
     // behind a captive portal.
     recheck_policy_.backoff_policy.initial_delay_ms =
         recheck_policy_.initial_backoff_portal_ms;
   } else {
     recheck_policy_.backoff_policy.initial_delay_ms =
         recheck_policy_.initial_backoff_no_portal_ms;
   }
 
-  backoff_entry_.reset(new RecheckBackoffEntry(this));
+  backoff_entry_.reset(new net::BackoffEntry(
+      &recheck_policy().backoff_policy,
+      this));
 }
 
 void CaptivePortalService::UpdateEnabledState() {
   DCHECK(CalledOnValidThread());
   bool enabled_before = enabled_;
   enabled_ = testing_state_ != DISABLED_FOR_TESTING &&
              resolve_errors_with_web_service_.GetValue();
 
   if (testing_state_ != SKIP_OS_CHECK_FOR_TESTING &&
       testing_state_ != IGNORE_REQUESTS_FOR_TESTING &&
@@ skipping 17 matching lines @@
     check_captive_portal_timer_.Stop();
     captive_portal_detector_.Cancel();
     state_ = STATE_IDLE;
 
     // Since a captive portal request was queued or running, something may be
     // expecting to receive a captive portal result.
     DetectCaptivePortal();
   }
 }
 
-base::TimeTicks CaptivePortalService::GetCurrentTimeTicks() const {
+base::TimeTicks CaptivePortalService::NowTicks() {
   if (time_ticks_for_testing_.is_null())
     return base::TimeTicks::Now();
   else
     return time_ticks_for_testing_;
 }
 
 bool CaptivePortalService::DetectionInProgress() const {
   return state_ == STATE_CHECKING_FOR_PORTAL;
 }
 
 bool CaptivePortalService::TimerRunning() const {
   return check_captive_portal_timer_.IsRunning();
 }