Use OnceClosure in TestPendingTask

device/bluetooth/test/bluetooth_test_win.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 "device/bluetooth/test/bluetooth_test_win.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/test/test_pending_task.h"
 #include "base/time/time.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
 #include "device/bluetooth/bluetooth_low_energy_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_win.h"
 
 namespace {
 
+// TODO(tzik): Remove this after base::TaskRunner migrates from base::Closure to
+// base::OnceClosure.
+base::RepeatingClosure UnsafeConvertOnceClosureToRepeating(
+    base::OnceClosure closure) {
+  return base::BindRepeating(
+      [](base::OnceClosure closure) { std::move(closure).Run(); },
+      base::Passed(&closure));
+}
+
 BLUETOOTH_ADDRESS CanonicalStringToBLUETOOTH_ADDRESS(
     std::string device_address) {
   BLUETOOTH_ADDRESS win_addr;
   unsigned int data[6];
   int result =
       sscanf_s(device_address.c_str(), "%02X:%02X:%02X:%02X:%02X:%02X",
                &data[5], &data[4], &data[3], &data[2], &data[1], &data[0]);
   CHECK(result == 6);
   for (int i = 0; i < 6; i++) {
     win_addr.rgBytes[i] = data[i];
@@ skipping 438 matching lines @@
   return fake_bt_le_wrapper_->GetSimulatedGattCharacteristic(
       target_service, std::to_string(win_characteristic->GetAttributeHandle()));
 }
 
 void BluetoothTestWin::RunPendingTasksUntilCallback() {
   std::deque<base::TestPendingTask> tasks =
       bluetooth_task_runner_->TakePendingTasks();
   int original_callback_count = callback_count_;
   int original_error_callback_count = error_callback_count_;
   do {
-    base::TestPendingTask task = tasks.front();
+    base::TestPendingTask task = std::move(tasks.front());
     tasks.pop_front();
-    task.task.Run();
+    std::move(task.task).Run();
     base::RunLoop().RunUntilIdle();
   } while (tasks.size() && callback_count_ == original_callback_count &&
            error_callback_count_ == original_error_callback_count);
 
   // Put the rest of pending tasks back to Bluetooth task runner.
-  for (const auto& task : tasks) {
+  for (auto& task : tasks) {
     if (task.delay.is_zero()) {
-      bluetooth_task_runner_->PostTask(task.location, task.task);
+      bluetooth_task_runner_->PostTask(
+          task.location,
+          UnsafeConvertOnceClosureToRepeating(std::move(task.task)));
     } else {
-      bluetooth_task_runner_->PostDelayedTask(task.location, task.task,
-                                              task.delay);
+      bluetooth_task_runner_->PostDelayedTask(
+          task.location,
+          UnsafeConvertOnceClosureToRepeating(std::move(task.task)),
+          task.delay);
     }
   }
 }
 
 void BluetoothTestWin::ForceRefreshDevice() {
   adapter_win_->force_update_device_for_test_ = true;
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::FinishPendingTasks() {
   bluetooth_task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 }
 }