Add a repeating probe functionality to AvailabilityProber

This will be used for litepages in a follow up CL.

Bug: 971918
Change-Id: I7faf3f8e0bc51fa1fff8235226f5832876c7492a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1730767Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Commit-Queue: Robert Ogden <robertogden@chromium.org>
Cr-Commit-Position: refs/heads/master@{#683276}

chrome/browser/availability/availability_prober.cc

@@ -5,6 +5,7 @@
 #include "chrome/browser/availability/availability_prober.h"
 
 #include <math.h>
+
 #include <cmath>
 
 #include "base/base64.h"
@@ -347,6 +348,19 @@ void AvailabilityProber::SendNowIfInactive(bool send_only_in_foreground) {
   CreateAndStartURLLoader();
 }
 
+void AvailabilityProber::RepeatedlyProbe(base::TimeDelta interval,
+                                         bool send_only_in_foreground) {
+  repeating_timer_ = std::make_unique<base::RepeatingTimer>(tick_clock_);
+  // base::Unretained is safe here because |repeating_timer_| is owned by
+  // |this|.
+  repeating_timer_->Start(
+      FROM_HERE, interval,
+      base::BindRepeating(&AvailabilityProber::SendNowIfInactive,
+                          base::Unretained(this), send_only_in_foreground));
+
+  SendNowIfInactive(send_only_in_foreground);
+}
+
 #if defined(OS_ANDROID)
 void AvailabilityProber::OnApplicationStateChange(
     base::android::ApplicationState new_state) {

chrome/browser/availability/availability_prober.h

@@ -6,6 +6,7 @@
 #define CHROME_BROWSER_AVAILABILITY_AVAILABILITY_PROBER_H_
 
 #include <stdint.h>
+
 #include <memory>
 #include <string>
 
@@ -156,6 +157,12 @@ class AvailabilityProber
   // is in the foreground (work on Android only).
   void SendNowIfInactive(bool send_only_in_foreground);
 
+  // Calls |SendNowIfInactive| immediately with |send_only_in_foreground| and
+  // repeats every |interval|. Calling this multiple times with different
+  // |interval| will change the interval to the most recently provided value.
+  // Only stops when |this| is deleted.
+  void RepeatedlyProbe(base::TimeDelta interval, bool send_only_in_foreground);
+
   // Returns the successfulness of the last probe, if there was one. If the last
   // probe status was cached and needs to be revalidated, this may activate the
   // prober.
@@ -254,6 +261,9 @@ class AvailabilityProber
   // If a probe is being attempted, this will be running until the TTL.
   std::unique_ptr<base::OneShotTimer> timeout_timer_;
 
+  // If we are repeatedly probing, this will be running.
+  std::unique_ptr<base::RepeatingTimer> repeating_timer_;
+
   // Caches past probe results in a mapping of one tuple to another:
   //   (network_id, url_) -> (last_probe_status, last_modification_time).
   // No more than |max_cache_entries_| will be kept in this dictionary.

chrome/browser/availability/availability_prober_unittest.cc

@@ -851,3 +851,24 @@ TEST_F(AvailabilityProberTest, CacheEntryAge) {
   histogram_tester.ExpectTotalCount(
       "Availability.Prober.CacheEntryAge.Litepages", 2);
 }
+
+TEST_F(AvailabilityProberTest, Repeating) {
+  base::HistogramTester histogram_tester;
+
+  std::unique_ptr<AvailabilityProber> prober = NewProber();
+  EXPECT_EQ(prober->LastProbeWasSuccessful(), base::nullopt);
+
+  prober->RepeatedlyProbe(base::TimeDelta::FromSeconds(1), false);
+  VerifyRequest();
+  MakeResponseAndWait(net::HTTP_OK, net::OK);
+  EXPECT_TRUE(prober->LastProbeWasSuccessful().value());
+  EXPECT_FALSE(prober->is_active());
+
+  FastForward(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(prober->is_active());
+
+  VerifyRequest();
+  MakeResponseAndWait(net::HTTP_OK, net::OK);
+  EXPECT_TRUE(prober->LastProbeWasSuccessful().value());
+  EXPECT_FALSE(prober->is_active());
+}