Reporting API: Use BindRepeating and RepeatingCallback.

Move to the shiny new explicit BindRepeating function and RepeatingCallback type.

Bug: 
Change-Id: I06257e24ade60e7670e0c1d8e23c267f59eb7216
Reviewed-on: https://chromium-review.googlesource.com/806478
Commit-Queue: Julia Tuttle <juliatuttle@chromium.org>
Reviewed-by: Miriam Gershenson <mgersh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521765}

net/network_error_logging/network_error_logging_service_unittest.cc

@@ -76,7 +76,7 @@ class TestReportingService : public ReportingService {
 
   void RemoveBrowsingData(
       int data_type_mask,
-      base::Callback<bool(const GURL&)> origin_filter) override {
+      base::RepeatingCallback<bool(const GURL&)> origin_filter) override {
     NOTREACHED();
   }
 

net/reporting/reporting_browsing_data_remover.cc

@@ -17,7 +17,7 @@ namespace net {
 void ReportingBrowsingDataRemover::RemoveBrowsingData(
     ReportingCache* cache,
     int data_type_mask,
-    base::Callback<bool(const GURL&)> origin_filter) {
+    base::RepeatingCallback<bool(const GURL&)> origin_filter) {
   bool remove_reports = (data_type_mask & DATA_TYPE_REPORTS) != 0;
   bool remove_clients = (data_type_mask & DATA_TYPE_CLIENTS) != 0;
 

net/reporting/reporting_browsing_data_remover.h

@@ -33,7 +33,7 @@ class NET_EXPORT ReportingBrowsingDataRemover {
   static void RemoveBrowsingData(
       ReportingCache* cache,
       int data_type_mask,
-      base::Callback<bool(const GURL&)> origin_filter);
+      base::RepeatingCallback<bool(const GURL&)> origin_filter);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ReportingBrowsingDataRemover);

net/reporting/reporting_browsing_data_remover_unittest.cc

@@ -29,10 +29,10 @@ class ReportingBrowsingDataRemoverTest : public ReportingTestBase {
     if (remove_clients)
       data_type_mask |= ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS;
 
-    base::Callback<bool(const GURL&)> origin_filter;
+    base::RepeatingCallback<bool(const GURL&)> origin_filter;
     if (!host.empty()) {
       origin_filter =
-          base::Bind(&ReportingBrowsingDataRemoverTest::HostIs, host);
+          base::BindRepeating(&ReportingBrowsingDataRemoverTest::HostIs, host);
     }
 
     ReportingBrowsingDataRemover::RemoveBrowsingData(cache(), data_type_mask,

net/reporting/reporting_delivery_agent.cc

@@ -97,8 +97,8 @@ class ReportingDeliveryAgentImpl : public ReportingDeliveryAgent,
 
   void StartTimer() {
     timer_->Start(FROM_HERE, policy().delivery_interval,
-                  base::Bind(&ReportingDeliveryAgentImpl::OnTimerFired,
-                             base::Unretained(this)));
+                  base::BindRepeating(&ReportingDeliveryAgentImpl::OnTimerFired,
+                                      base::Unretained(this)));
   }
 
   void OnTimerFired() {
@@ -160,9 +160,9 @@ class ReportingDeliveryAgentImpl : public ReportingDeliveryAgent,
 
       uploader()->StartUpload(
           endpoint, json,
-          base::Bind(&ReportingDeliveryAgentImpl::OnUploadComplete,
-                     weak_factory_.GetWeakPtr(),
-                     std::make_unique<Delivery>(endpoint, reports)));
+          base::BindOnce(&ReportingDeliveryAgentImpl::OnUploadComplete,
+                         weak_factory_.GetWeakPtr(),
+                         std::make_unique<Delivery>(endpoint, reports)));
     }
   }
 

net/reporting/reporting_garbage_collector.cc

@@ -43,9 +43,10 @@ class ReportingGarbageCollectorImpl : public ReportingGarbageCollector,
     if (timer_->IsRunning())
       return;
 
-    timer_->Start(FROM_HERE, context_->policy().garbage_collection_interval,
-                  base::Bind(&ReportingGarbageCollectorImpl::CollectGarbage,
-                             base::Unretained(this)));
+    timer_->Start(
+        FROM_HERE, context_->policy().garbage_collection_interval,
+        base::BindRepeating(&ReportingGarbageCollectorImpl::CollectGarbage,
+                            base::Unretained(this)));
   }
 
  private:

net/reporting/reporting_service.cc

@@ -47,7 +47,7 @@ class ReportingServiceImpl : public ReportingService {
 
   void RemoveBrowsingData(
       int data_type_mask,
-      base::Callback<bool(const GURL&)> origin_filter) override {
+      base::RepeatingCallback<bool(const GURL&)> origin_filter) override {
     ReportingBrowsingDataRemover::RemoveBrowsingData(
         context_->cache(), data_type_mask, origin_filter);
   }

net/reporting/reporting_service.h

@@ -63,7 +63,7 @@ class NET_EXPORT ReportingService {
   // ReportingBrowsingDataRemover for more details.
   virtual void RemoveBrowsingData(
       int data_type_mask,
-      base::Callback<bool(const GURL&)> origin_filter) = 0;
+      base::RepeatingCallback<bool(const GURL&)> origin_filter) = 0;
 
  protected:
   ReportingService() {}

net/reporting/reporting_test_util.cc

@@ -32,15 +32,14 @@ namespace {
 
 class PendingUploadImpl : public TestReportingUploader::PendingUpload {
  public:
-  PendingUploadImpl(
-      const GURL& url,
-      const std::string& json,
-      const ReportingUploader::Callback& callback,
-      const base::Callback<void(PendingUpload*)>& complete_callback)
+  PendingUploadImpl(const GURL& url,
+                    const std::string& json,
+                    ReportingUploader::UploadCallback callback,
+                    base::OnceCallback<void(PendingUpload*)> complete_callback)
       : url_(url),
         json_(json),
-        callback_(callback),
-        complete_callback_(complete_callback) {}
+        callback_(std::move(callback)),
+        complete_callback_(std::move(complete_callback)) {}
 
   ~PendingUploadImpl() override = default;
 
@@ -52,16 +51,16 @@ class PendingUploadImpl : public TestReportingUploader::PendingUpload {
   }
 
   void Complete(ReportingUploader::Outcome outcome) override {
-    callback_.Run(outcome);
+    std::move(callback_).Run(outcome);
     // Deletes |this|.
-    complete_callback_.Run(this);
+    std::move(complete_callback_).Run(this);
   }
 
  private:
   GURL url_;
   std::string json_;
-  ReportingUploader::Callback callback_;
-  base::Callback<void(PendingUpload*)> complete_callback_;
+  ReportingUploader::UploadCallback callback_;
+  base::OnceCallback<void(PendingUpload*)> complete_callback_;
 };
 
 void ErasePendingUpload(
@@ -98,9 +97,10 @@ TestReportingUploader::~TestReportingUploader() = default;
 
 void TestReportingUploader::StartUpload(const GURL& url,
                                         const std::string& json,
-                                        const Callback& callback) {
+                                        UploadCallback callback) {
   pending_uploads_.push_back(std::make_unique<PendingUploadImpl>(
-      url, json, callback, base::Bind(&ErasePendingUpload, &pending_uploads_)));
+      url, json, std::move(callback),
+      base::BindOnce(&ErasePendingUpload, &pending_uploads_)));
 }
 
 TestReportingDelegate::TestReportingDelegate() = default;

net/reporting/reporting_test_util.h

@@ -68,7 +68,7 @@ class TestReportingUploader : public ReportingUploader {
   // ReportingUploader implementation:
   void StartUpload(const GURL& url,
                    const std::string& json,
-                   const Callback& callback) override;
+                   UploadCallback callback) override;
 
  private:
   std::vector<std::unique_ptr<PendingUpload>> pending_uploads_;

net/reporting/reporting_uploader.cc

@@ -47,7 +47,7 @@ class ReportingUploaderImpl : public ReportingUploader, URLRequest::Delegate {
 
   void StartUpload(const GURL& url,
                    const std::string& json,
-                   const Callback& callback) override {
+                   UploadCallback callback) override {
     net::NetworkTrafficAnnotationTag traffic_annotation =
         net::DefineNetworkTrafficAnnotation("reporting", R"(
         semantics {
@@ -95,7 +95,7 @@ class ReportingUploaderImpl : public ReportingUploader, URLRequest::Delegate {
     // Have to grab the unique_ptr* first to ensure request.get() happens
     // before std::move(request).
     std::unique_ptr<Upload>* upload = &uploads_[request.get()];
-    *upload = std::make_unique<Upload>(std::move(request), callback);
+    *upload = std::make_unique<Upload>(std::move(request), std::move(callback));
   }
 
   // URLRequest::Delegate implementation:
@@ -140,7 +140,7 @@ class ReportingUploaderImpl : public ReportingUploader, URLRequest::Delegate {
     int response_code = headers ? headers->response_code() : 0;
     Outcome outcome = ResponseCodeToOutcome(response_code);
 
-    upload->second.Run(outcome);
+    std::move(upload->second).Run(outcome);
 
     request->Cancel();
   }
@@ -152,7 +152,7 @@ class ReportingUploaderImpl : public ReportingUploader, URLRequest::Delegate {
   }
 
  private:
-  using Upload = std::pair<std::unique_ptr<URLRequest>, Callback>;
+  using Upload = std::pair<std::unique_ptr<URLRequest>, UploadCallback>;
 
   const URLRequestContext* context_;
   std::map<const URLRequest*, std::unique_ptr<Upload>> uploads_;

net/reporting/reporting_uploader.h

@@ -23,7 +23,7 @@ class NET_EXPORT ReportingUploader {
  public:
   enum class Outcome { SUCCESS, REMOVE_ENDPOINT, FAILURE };
 
-  using Callback = base::Callback<void(Outcome outcome)>;
+  using UploadCallback = base::OnceCallback<void(Outcome outcome)>;
 
   static const char kUploadContentType[];
 
@@ -33,7 +33,7 @@ class NET_EXPORT ReportingUploader {
   // |url|, and calls |callback| when complete (whether successful or not).
   virtual void StartUpload(const GURL& url,
                            const std::string& json,
-                           const Callback& callback) = 0;
+                           UploadCallback callback) = 0;
 
   // Creates a real implementation of |ReportingUploader| that uploads reports
   // using |context|.

net/reporting/reporting_uploader_unittest.cc

@@ -65,9 +65,9 @@ class TestUploadCallback {
  public:
   TestUploadCallback() : called_(false), waiting_(false) {}
 
-  ReportingUploader::Callback callback() {
-    return base::Bind(&TestUploadCallback::OnUploadComplete,
-                      base::Unretained(this));
+  ReportingUploader::UploadCallback callback() {
+    return base::BindOnce(&TestUploadCallback::OnUploadComplete,
+                          base::Unretained(this));
   }
 
   void WaitForCall() {
@@ -104,8 +104,8 @@ class TestUploadCallback {
 };
 
 TEST_F(ReportingUploaderTest, Upload) {
-  server_.RegisterRequestMonitor(base::Bind(&CheckUpload));
-  server_.RegisterRequestHandler(base::Bind(&ReturnResponse, HTTP_OK));
+  server_.RegisterRequestMonitor(base::BindRepeating(&CheckUpload));
+  server_.RegisterRequestHandler(base::BindRepeating(&ReturnResponse, HTTP_OK));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -114,7 +114,7 @@ TEST_F(ReportingUploaderTest, Upload) {
 }
 
 TEST_F(ReportingUploaderTest, Success) {
-  server_.RegisterRequestHandler(base::Bind(&ReturnResponse, HTTP_OK));
+  server_.RegisterRequestHandler(base::BindRepeating(&ReturnResponse, HTTP_OK));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -137,7 +137,7 @@ TEST_F(ReportingUploaderTest, NetworkError1) {
 }
 
 TEST_F(ReportingUploaderTest, NetworkError2) {
-  server_.RegisterRequestHandler(base::Bind(&ReturnInvalidResponse));
+  server_.RegisterRequestHandler(base::BindRepeating(&ReturnInvalidResponse));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -149,7 +149,7 @@ TEST_F(ReportingUploaderTest, NetworkError2) {
 
 TEST_F(ReportingUploaderTest, ServerError) {
   server_.RegisterRequestHandler(
-      base::Bind(&ReturnResponse, HTTP_INTERNAL_SERVER_ERROR));
+      base::BindRepeating(&ReturnResponse, HTTP_INTERNAL_SERVER_ERROR));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -160,7 +160,8 @@ TEST_F(ReportingUploaderTest, ServerError) {
 }
 
 TEST_F(ReportingUploaderTest, RemoveEndpoint) {
-  server_.RegisterRequestHandler(base::Bind(&ReturnResponse, HTTP_GONE));
+  server_.RegisterRequestHandler(
+      base::BindRepeating(&ReturnResponse, HTTP_GONE));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -199,8 +200,10 @@ std::unique_ptr<test_server::HttpResponse> CheckRedirect(
 
 TEST_F(ReportingUploaderTest, FollowHttpsRedirect) {
   bool followed = false;
-  server_.RegisterRequestHandler(base::Bind(&ReturnRedirect, kRedirectPath));
-  server_.RegisterRequestHandler(base::Bind(&CheckRedirect, &followed));
+  server_.RegisterRequestHandler(
+      base::BindRepeating(&ReturnRedirect, kRedirectPath));
+  server_.RegisterRequestHandler(
+      base::BindRepeating(&CheckRedirect, &followed));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -215,11 +218,13 @@ TEST_F(ReportingUploaderTest, DontFollowHttpRedirect) {
   bool followed = false;
 
   test_server::EmbeddedTestServer http_server_;
-  http_server_.RegisterRequestHandler(base::Bind(&CheckRedirect, &followed));
+  http_server_.RegisterRequestHandler(
+      base::BindRepeating(&CheckRedirect, &followed));
   ASSERT_TRUE(http_server_.Start());
 
   const GURL target = http_server_.GetURL(kRedirectPath);
-  server_.RegisterRequestHandler(base::Bind(&ReturnRedirect, target.spec()));
+  server_.RegisterRequestHandler(
+      base::BindRepeating(&ReturnRedirect, target.spec()));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback callback;
@@ -236,15 +241,15 @@ void CheckNoCookie(const test_server::HttpRequest& request) {
 }
 
 TEST_F(ReportingUploaderTest, DontSendCookies) {
-  server_.RegisterRequestMonitor(base::Bind(&CheckNoCookie));
-  server_.RegisterRequestHandler(base::Bind(&ReturnResponse, HTTP_OK));
+  server_.RegisterRequestMonitor(base::BindRepeating(&CheckNoCookie));
+  server_.RegisterRequestHandler(base::BindRepeating(&ReturnResponse, HTTP_OK));
   ASSERT_TRUE(server_.Start());
 
   ResultSavingCookieCallback<bool> cookie_callback;
   context_.cookie_store()->SetCookieWithOptionsAsync(
       server_.GetURL("/"), "foo=bar", CookieOptions(),
-      base::Bind(&ResultSavingCookieCallback<bool>::Run,
-                 base::Unretained(&cookie_callback)));
+      base::BindRepeating(&ResultSavingCookieCallback<bool>::Run,
+                          base::Unretained(&cookie_callback)));
   cookie_callback.WaitUntilDone();
   ASSERT_TRUE(cookie_callback.result());
 
@@ -265,7 +270,7 @@ std::unique_ptr<test_server::HttpResponse> SendCookie(
 }
 
 TEST_F(ReportingUploaderTest, DontSaveCookies) {
-  server_.RegisterRequestHandler(base::Bind(&SendCookie));
+  server_.RegisterRequestHandler(base::BindRepeating(&SendCookie));
   ASSERT_TRUE(server_.Start());
 
   TestUploadCallback upload_callback;
@@ -276,8 +281,8 @@ TEST_F(ReportingUploaderTest, DontSaveCookies) {
   GetCookieListCallback cookie_callback;
   context_.cookie_store()->GetCookieListWithOptionsAsync(
       server_.GetURL("/"), CookieOptions(),
-      base::Bind(&GetCookieListCallback::Run,
-                 base::Unretained(&cookie_callback)));
+      base::BindRepeating(&GetCookieListCallback::Run,
+                          base::Unretained(&cookie_callback)));
   cookie_callback.WaitUntilDone();
 
   EXPECT_TRUE(cookie_callback.cookies().empty());
@@ -302,7 +307,7 @@ std::unique_ptr<test_server::HttpResponse> ReturnCacheableResponse(
 TEST_F(ReportingUploaderTest, DontCacheResponse) {
   int request_count = 0;
   server_.RegisterRequestHandler(
-      base::Bind(&ReturnCacheableResponse, &request_count));
+      base::BindRepeating(&ReturnCacheableResponse, &request_count));
   ASSERT_TRUE(server_.Start());
 
   {