Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/safe_browsing

chrome/browser/safe_browsing/certificate_reporting_service_test_utils.cc

 // Copyright 2016 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/safe_browsing/certificate_reporting_service_test_utils.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/certificate_reporting/encrypted_cert_logger.pb.h"
 #include "components/certificate_reporting/error_report.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 194 matching lines @@
     return;
   }
   if (should_fail_) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_SSL_PROTOCOL_ERROR));
     return;
   }
   // Start reading asynchronously as would a normal network request.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&DelayableCertReportURLRequestJob::NotifyHeadersComplete,
-                 weak_factory_.GetWeakPtr()));
+      base::BindOnce(&DelayableCertReportURLRequestJob::NotifyHeadersComplete,
+                     weak_factory_.GetWeakPtr()));
 }
 
 CertReportJobInterceptor::CertReportJobInterceptor(
     ReportSendingResult expected_report_result,
     const uint8_t* server_private_key)
     : expected_report_result_(expected_report_result),
       server_private_key_(server_private_key),
       weak_factory_(this) {}
 
 CertReportJobInterceptor::~CertReportJobInterceptor() {}
 
 net::URLRequestJob* CertReportJobInterceptor::MaybeInterceptRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   const std::string serialized_report =
       GetReportContents(request, server_private_key_);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&CertReportJobInterceptor::RequestCreated,
-                 weak_factory_.GetWeakPtr(), serialized_report,
-                 expected_report_result_));
+      base::BindOnce(&CertReportJobInterceptor::RequestCreated,
+                     weak_factory_.GetWeakPtr(), serialized_report,
+                     expected_report_result_));
 
   if (expected_report_result_ == REPORTS_FAIL) {
     return new DelayableCertReportURLRequestJob(
         false, true, request, network_delegate,
         base::Bind(&CertReportJobInterceptor::RequestDestructed,
                    base::Unretained(this), serialized_report,
                    expected_report_result_));
 
   } else if (expected_report_result_ == REPORTS_DELAY) {
     DCHECK(!delayed_request_) << "Supports only one delayed request at a time";
@@ skipping 12 matching lines @@
       base::Bind(&CertReportJobInterceptor::RequestDestructed,
                  base::Unretained(this), serialized_report,
                  expected_report_result_));
 }
 
 void CertReportJobInterceptor::SetFailureMode(
     ReportSendingResult expected_report_result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CertReportJobInterceptor::SetFailureModeOnIOThread,
-                 weak_factory_.GetWeakPtr(), expected_report_result));
+      base::BindOnce(&CertReportJobInterceptor::SetFailureModeOnIOThread,
+                     weak_factory_.GetWeakPtr(), expected_report_result));
 }
 
 void CertReportJobInterceptor::Resume() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CertReportJobInterceptor::ResumeOnIOThread,
-                 base::Unretained(this)));
+      base::BindOnce(&CertReportJobInterceptor::ResumeOnIOThread,
+                     base::Unretained(this)));
 }
 
 RequestObserver* CertReportJobInterceptor::request_created_observer() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return &request_created_observer_;
 }
 
 RequestObserver* CertReportJobInterceptor::request_destroyed_observer() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return &request_destroyed_observer_;
@@ skipping 89 matching lines @@
 
 CertificateReportingServiceTestHelper::
     ~CertificateReportingServiceTestHelper() {}
 
 void CertificateReportingServiceTestHelper::SetUpInterceptor() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   url_request_interceptor_ =
       new CertReportJobInterceptor(REPORTS_FAIL, server_private_key_);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&SetUpURLHandlersOnIOThread,
-                 base::Passed(std::unique_ptr<net::URLRequestInterceptor>(
-                     url_request_interceptor_))));
+      base::BindOnce(&SetUpURLHandlersOnIOThread,
+                     base::Passed(std::unique_ptr<net::URLRequestInterceptor>(
+                         url_request_interceptor_))));
 }
 
 void CertificateReportingServiceTestHelper::SetFailureMode(
     ReportSendingResult expected_report_result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   url_request_interceptor_->SetFailureMode(expected_report_result);
 }
 
 void CertificateReportingServiceTestHelper::ResumeDelayedRequest() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 34 matching lines @@
 
   if (service->GetReporterForTesting()) {
     // Reporter can be null if reporting is disabled.
     EXPECT_EQ(
         0u,
         service->GetReporterForTesting()->inflight_report_count_for_testing());
   }
 }
 
 }  // namespace certificate_reporting_test_utils