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 {
- public:
-  explicit RecheckBackoffEntry(CaptivePortalService* captive_portal_service)
-      : net::BackoffEntry(
-            &captive_portal_service->recheck_policy().backoff_policy),
-        captive_portal_service_(captive_portal_service) {
-  }
-
- private:
-  base::TimeTicks ImplGetTimeNow() const override {
-    return captive_portal_service_->GetCurrentTimeTicks();
-  }
-
-  CaptivePortalService* captive_portal_service_;
-
-  DISALLOW_COPY_AND_ASSIGN(RecheckBackoffEntry);
-};
-
 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.
   //
   // A value of 6 means to start backoff on the 7th failure, which is the 8th
   // time the same result is received.
   backoff_policy.num_errors_to_ignore = 6;
 
   // It doesn't matter what this is initialized to.  It will be overwritten
   // after the first captive portal detection request.
   backoff_policy.initial_delay_ms = initial_backoff_no_portal_ms;
 
   backoff_policy.multiply_factor = 2.0;
   backoff_policy.jitter_factor = 0.3;
   backoff_policy.maximum_backoff_ms = 2 * 60 * 1000;
 
   // -1 means the entry never expires.  This doesn't really matter, as the
   // service never checks for its expiration.
   backoff_policy.entry_lifetime_ms = -1;
 
   backoff_policy.always_use_initial_delay = true;
 }
 
 CaptivePortalService::CaptivePortalService(Profile* profile)
+    : CaptivePortalService(profile, nullptr) {
+}
+
+CaptivePortalService::CaptivePortalService(Profile* profile,
+                                           base::TickClock* clock_for_testing)
     : profile_(profile),
       state_(STATE_IDLE),
       captive_portal_detector_(profile->GetRequestContext()),
       enabled_(false),
       last_detection_result_(captive_portal::RESULT_INTERNET_CONNECTED),
       num_checks_with_same_result_(0),
-      test_url_(captive_portal::CaptivePortalDetector::kDefaultURL) {
+      test_url_(captive_portal::CaptivePortalDetector::kDefaultURL),
+      tick_clock_for_testing_(clock_for_testing) {
   // The order matters here:
   // |resolve_errors_with_web_service_| must be initialized and |backoff_entry_|
   // created before the call to UpdateEnabledState.
   resolve_errors_with_web_service_.Init(
       prefs::kAlternateErrorPagesEnabled,
       profile_->GetPrefs(),
       base::Bind(&CaptivePortalService::UpdateEnabledState,
                  base::Unretained(this)));
   ResetBackoffEntry(last_detection_result_);
 
@@ skipping 137 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,
+                                             tick_clock_for_testing_));
 }
 
 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 18 matching lines @@
     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 {
-  if (time_ticks_for_testing_.is_null())
+  if (tick_clock_for_testing_)
+    return tick_clock_for_testing_->NowTicks();
+  else
     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();
 }