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

chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.cc

 // Copyright 2014 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/incident_reporting/incident_reporting_service.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include <algorithm>
@@ skipping 211 matching lines @@
   AddIncidentOnMainThread(service_, profile, std::move(incident));
 }
 
 void IncidentReportingService::Receiver::AddIncidentForProcess(
     std::unique_ptr<Incident> incident) {
   if (thread_runner_->BelongsToCurrentThread()) {
     AddIncidentOnMainThread(service_, nullptr, std::move(incident));
   } else {
     thread_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&IncidentReportingService::Receiver::AddIncidentOnMainThread,
-                   service_, nullptr, base::Passed(&incident)));
+        base::BindOnce(
+            &IncidentReportingService::Receiver::AddIncidentOnMainThread,
+            service_, nullptr, base::Passed(&incident)));
   }
 }
 
 void IncidentReportingService::Receiver::ClearIncidentForProcess(
     std::unique_ptr<Incident> incident) {
   if (thread_runner_->BelongsToCurrentThread()) {
     ClearIncidentOnMainThread(service_, nullptr, std::move(incident));
   } else {
     thread_runner_->PostTask(
         FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &IncidentReportingService::Receiver::ClearIncidentOnMainThread,
             service_, nullptr, base::Passed(&incident)));
   }
 }
 
 bool IncidentReportingService::HasIncidentsToUpload() const {
   for (const auto& profile_and_context : profiles_) {
     if (!profile_and_context.second->incidents.empty())
       return true;
   }
@@ skipping 429 matching lines @@
   if (environment_collection_pending_ || report_->has_environment() ||
       !HasIncidentsToUpload() || !FindEligibleProfile()) {
     return;
   }
 
   environment_collection_begin_ = base::TimeTicks::Now();
   ClientIncidentReport_EnvironmentData* environment_data =
       new ClientIncidentReport_EnvironmentData();
   environment_collection_pending_ =
       environment_collection_task_runner_->PostTaskAndReply(
-          FROM_HERE, base::Bind(collect_environment_data_fn_, environment_data),
-          base::Bind(&IncidentReportingService::OnEnvironmentDataCollected,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(base::WrapUnique(environment_data))));
+          FROM_HERE,
+          base::BindOnce(collect_environment_data_fn_, environment_data),
+          base::BindOnce(&IncidentReportingService::OnEnvironmentDataCollected,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         base::Passed(base::WrapUnique(environment_data))));
 
   // Posting the task will fail if the runner has been shut down. This should
   // never happen since the blocking pool is shut down after this service.
   DCHECK(environment_collection_pending_);
 }
 
 bool IncidentReportingService::WaitingForEnvironmentCollection() {
   return environment_collection_pending_;
 }
 
@@ skipping 346 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing