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

chrome/browser/safe_browsing/certificate_reporting_service_unittest.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.h"
 
 #include <string>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 331 matching lines @@
 
   ~CertificateReportingServiceTest() override {}
 
   void SetUp() override {
     service_observer_.Clear();
     test_helper_.SetUpInterceptor();
     WaitForIOThread();
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &CertificateReportingServiceTest::SetUpURLRequestContextOnIOThread,
             base::Unretained(this)));
     WaitForIOThread();
 
     safe_browsing::SafeBrowsingService::RegisterFactory(&sb_service_factory);
     sb_service_ = sb_service_factory.CreateSafeBrowsingService();
 
     clock_.reset(new base::SimpleTestClock());
     service_.reset(new CertificateReportingService(
         sb_service_.get(), url_request_context_getter(), &profile_,
         test_helper_.server_public_key(),
         test_helper_.server_public_key_version(), kMaxReportCountInQueue,
         base::TimeDelta::FromHours(24), clock_.get(),
         base::Bind(&CertificateReportingServiceObserver::OnServiceReset,
                    base::Unretained(&service_observer_))));
     service_observer_.WaitForReset();
   }
 
   void TearDown() override {
     WaitForIOThread();
     test_helper()->ExpectNoRequests(service());
 
     service_->Shutdown();
     WaitForIOThread();
     service_.reset(nullptr);
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&CertificateReportingServiceTest::TearDownOnIOThread,
-                   base::Unretained(this)));
+        base::BindOnce(&CertificateReportingServiceTest::TearDownOnIOThread,
+                       base::Unretained(this)));
     content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                     base::Bind(&ClearURLHandlers));
+                                     base::BindOnce(&ClearURLHandlers));
     WaitForIOThread();
 
     histogram_test_helper_.CheckHistogram();
   }
 
  protected:
   net::URLRequestContextGetter* url_request_context_getter() {
     return url_request_context_getter_.get();
   }
 
   void WaitForIOThread() {
     scoped_refptr<base::ThreadTestHelper> io_helper(
         new base::ThreadTestHelper(io_task_runner_));
     ASSERT_TRUE(io_helper->Run());
   }
 
   CertificateReportingService* service() { return service_.get(); }
 
   // Sets service enabled state and waits for a reset event.
   void SetServiceEnabledAndWait(bool enabled) {
     service_observer_.Clear();
     service()->SetEnabled(enabled);
     service_observer_.WaitForReset();
   }
 
   void AdvanceClock(base::TimeDelta delta) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&base::SimpleTestClock::Advance,
-                   base::Unretained(clock_.get()), delta));
+        base::BindOnce(&base::SimpleTestClock::Advance,
+                       base::Unretained(clock_.get()), delta));
   }
 
   void SetNow(base::Time now) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&base::SimpleTestClock::SetNow,
-                   base::Unretained(clock_.get()), now));
+        base::BindOnce(&base::SimpleTestClock::SetNow,
+                       base::Unretained(clock_.get()), now));
   }
 
   void SetExpectedFailedReportCountOnTearDown(unsigned int count) {
     histogram_test_helper_.SetExpectedFailedReportCount(count);
   }
 
   CertificateReportingServiceTestHelper* test_helper() { return &test_helper_; }
 
  private:
   void SetUpURLRequestContextOnIOThread() {
@@ skipping 271 matching lines @@
   // callbacks should be called. The report id is again 0 since the pending
   // report queue has been cleared above.
   service()->Send(MakeReport("report1"));
 
   // Resume delayed report. Two reports are successfully sent.
   test_helper()->ResumeDelayedRequest();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED},
                                   {"report1", RetryStatus::NOT_RETRIED}}));
 }