[base] Apply BindOnceRewriter in //device/bluetooth/bluez

This change applies the BindOnceRewriter in //device/bluetooth/bluez.
This rewriter replaces calls to base::Bind and base::BindRepeating with
calls to base::BindOnce, in case the result is immediately assigned to a
base::OnceCallback. Given that base::RepeatingCallback is implicitly
convertible to base::OnceCallback, there is no change in functionality.

Steps:
  1. run_tool.py --tool base_bind_rewriters \
                 --tool-arg='--rewriter=bind_to_bind_once'
  2. git cl format

This CL was uploaded by git cl split.

R=sonnysasaka@chromium.org

Bug: 714018
Change-Id: I294a17baa39c390c53928676b4c3cefd09f67e37
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2132135
Auto-Submit: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Sonny Sasaka <sonnysasaka@chromium.org>
Commit-Queue: Sonny Sasaka <sonnysasaka@chromium.org>
Cr-Commit-Position: refs/heads/master@{#755456}

device/bluetooth/bluez/bluetooth_adapter_bluez.cc

@@ -352,9 +352,9 @@ void BluetoothAdapterBlueZ::SetName(const std::string& name,
       ->GetBluetoothAdapterClient()
       ->GetProperties(object_path_)
       ->alias.Set(
-          name,
-          base::Bind(&BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
-                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
+          name, base::BindOnce(
+                    &BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
+                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 bool BluetoothAdapterBlueZ::IsInitialized() const {
@@ -393,8 +393,9 @@ void BluetoothAdapterBlueZ::SetPowered(bool powered,
       ->GetProperties(object_path_)
       ->powered.Set(
           powered,
-          base::Bind(&BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
-                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
+          base::BindOnce(&BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
+                         weak_ptr_factory_.GetWeakPtr(), callback,
+                         error_callback));
 }
 
 bool BluetoothAdapterBlueZ::IsDiscoverable() const {
@@ -425,8 +426,9 @@ void BluetoothAdapterBlueZ::SetDiscoverable(
       ->GetProperties(object_path_)
       ->discoverable.Set(
           discoverable,
-          base::Bind(&BluetoothAdapterBlueZ::OnSetDiscoverable,
-                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
+          base::BindOnce(&BluetoothAdapterBlueZ::OnSetDiscoverable,
+                         weak_ptr_factory_.GetWeakPtr(), callback,
+                         error_callback));
 }
 
 uint32_t BluetoothAdapterBlueZ::GetDiscoverableTimeout() const {
@@ -559,7 +561,7 @@ void BluetoothAdapterBlueZ::SetAdvertisingInterval(
       ->GetBluetoothLEAdvertisingManagerClient()
       ->SetAdvertisingInterval(
           object_path_, min_ms, max_ms, callback,
-          base::Bind(&SetIntervalErrorCallbackConnector, error_callback));
+          base::BindOnce(&SetIntervalErrorCallbackConnector, error_callback));
 }
 
 void BluetoothAdapterBlueZ::ResetAdvertising(
@@ -568,9 +570,9 @@ void BluetoothAdapterBlueZ::ResetAdvertising(
   DCHECK(bluez::BluezDBusManager::Get());
   bluez::BluezDBusManager::Get()
       ->GetBluetoothLEAdvertisingManagerClient()
-      ->ResetAdvertising(
-          object_path_, callback,
-          base::Bind(&ResetAdvertisingErrorCallbackConnector, error_callback));
+      ->ResetAdvertising(object_path_, callback,
+                         base::BindOnce(&ResetAdvertisingErrorCallbackConnector,
+                                        error_callback));
 }
 
 device::BluetoothLocalGattService* BluetoothAdapterBlueZ::GetGattService(
@@ -985,8 +987,8 @@ void BluetoothAdapterBlueZ::CreateServiceRecord(
       ->GetBluetoothAdapterClient()
       ->CreateServiceRecord(
           object_path_, record, callback,
-          base::Bind(&BluetoothAdapterBlueZ::ServiceRecordErrorConnector,
-                     weak_ptr_factory_.GetWeakPtr(), error_callback));
+          base::BindOnce(&BluetoothAdapterBlueZ::ServiceRecordErrorConnector,
+                         weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothAdapterBlueZ::RemoveServiceRecord(
@@ -997,8 +999,8 @@ void BluetoothAdapterBlueZ::RemoveServiceRecord(
       ->GetBluetoothAdapterClient()
       ->RemoveServiceRecord(
           object_path_, handle, callback,
-          base::Bind(&BluetoothAdapterBlueZ::ServiceRecordErrorConnector,
-                     weak_ptr_factory_.GetWeakPtr(), error_callback));
+          base::BindOnce(&BluetoothAdapterBlueZ::ServiceRecordErrorConnector,
+                         weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 BluetoothDeviceBlueZ* BluetoothAdapterBlueZ::GetDeviceWithPath(
@@ -1481,9 +1483,9 @@ void BluetoothAdapterBlueZ::OnSetDiscoverable(
       ->GetBluetoothAdapterClient()
       ->GetProperties(object_path_)
       ->discoverable_timeout.Set(
-          0,
-          base::Bind(&BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
-                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
+          0, base::BindOnce(&BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
+                            weak_ptr_factory_.GetWeakPtr(), callback,
+                            error_callback));
 }
 
 void BluetoothAdapterBlueZ::OnPropertyChangeCompleted(
@@ -1569,7 +1571,7 @@ void BluetoothAdapterBlueZ::StartScanWithFilter(
   // This is the first request to start device discovery.
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
       object_path_,
-      base::BindRepeating(
+      base::BindOnce(
           &BluetoothAdapterBlueZ::OnStartDiscovery,
           weak_ptr_factory_.GetWeakPtr(),
           base::BindRepeating(copyable_callback, /*is_error=*/false,
@@ -1605,7 +1607,7 @@ void BluetoothAdapterBlueZ::StopScan(DiscoverySessionResultCallback callback) {
   auto copyable_callback = base::AdaptCallbackForRepeating(std::move(callback));
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StopDiscovery(
       object_path_,
-      base::BindRepeating(
+      base::BindOnce(
           &BluetoothAdapterBlueZ::OnStopDiscovery,
           weak_ptr_factory_.GetWeakPtr(),
           base::BindRepeating(copyable_callback, /*is_error=*/false,
@@ -1664,9 +1666,9 @@ void BluetoothAdapterBlueZ::SetDiscoveryFilter(
       ->GetBluetoothAdapterClient()
       ->SetDiscoveryFilter(
           object_path_, dbus_discovery_filter,
-          base::BindRepeating(&BluetoothAdapterBlueZ::OnSetDiscoveryFilter,
-                              weak_ptr_factory_.GetWeakPtr(), callback,
-                              copyable_error_callback),
+          base::BindOnce(&BluetoothAdapterBlueZ::OnSetDiscoveryFilter,
+                         weak_ptr_factory_.GetWeakPtr(), callback,
+                         copyable_error_callback),
           base::BindOnce(&BluetoothAdapterBlueZ::OnSetDiscoveryFilterError,
                          weak_ptr_factory_.GetWeakPtr(), callback,
                          copyable_error_callback));
@@ -1744,9 +1746,9 @@ void BluetoothAdapterBlueZ::OnPreSetDiscoveryFilter(
       base::AdaptCallbackForRepeating(std::move(error_callback));
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
       object_path_,
-      base::BindRepeating(&BluetoothAdapterBlueZ::OnStartDiscovery,
-                          weak_ptr_factory_.GetWeakPtr(), callback,
-                          copyable_error_callback),
+      base::BindOnce(&BluetoothAdapterBlueZ::OnStartDiscovery,
+                     weak_ptr_factory_.GetWeakPtr(), callback,
+                     copyable_error_callback),
       base::BindOnce(&BluetoothAdapterBlueZ::OnStartDiscoveryError,
                      weak_ptr_factory_.GetWeakPtr(), callback,
                      copyable_error_callback));

device/bluetooth/bluez/bluetooth_adapter_profile_bluez_unittest.cc

@@ -225,10 +225,11 @@ TEST_F(BluetoothAdapterProfileBlueZTest, BlackHole) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kPairedDevicePath),
       bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
+          base::Unretained(this)),
+      base::BindOnce(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
+                     base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
@@ -267,10 +268,11 @@ TEST_F(BluetoothAdapterProfileBlueZTest, Routing) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kPairedDevicePath),
       bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
+          base::Unretained(this)),
+      base::BindOnce(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
+                     base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
@@ -282,10 +284,11 @@ TEST_F(BluetoothAdapterProfileBlueZTest, Routing) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLegacyAutopairPath),
       bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
+          base::Unretained(this)),
+      base::BindOnce(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
+                     base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
@@ -298,10 +301,11 @@ TEST_F(BluetoothAdapterProfileBlueZTest, Routing) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kDisplayPinCodePath),
       bluez::FakeBluetoothProfileManagerClient::kRfcommUuid,
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &BluetoothAdapterProfileBlueZTest::DBusConnectSuccessCallback,
+          base::Unretained(this)),
+      base::BindOnce(&BluetoothAdapterProfileBlueZTest::DBusErrorCallback,
+                     base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 

device/bluetooth/bluez/bluetooth_advertisement_bluez.cc

@@ -99,7 +99,7 @@ void BluetoothAdvertisementBlueZ::Register(
       ->GetBluetoothLEAdvertisingManagerClient()
       ->RegisterAdvertisement(
           adapter_path_, provider_->object_path(), success_callback,
-          base::Bind(&RegisterErrorCallbackConnector, error_callback));
+          base::BindOnce(&RegisterErrorCallbackConnector, error_callback));
 }
 
 BluetoothAdvertisementBlueZ::~BluetoothAdvertisementBlueZ() {
@@ -122,7 +122,7 @@ void BluetoothAdvertisementBlueZ::Unregister(
       ->GetBluetoothLEAdvertisingManagerClient()
       ->UnregisterAdvertisement(
           adapter_path_, provider_->object_path(), success_callback,
-          base::Bind(&UnregisterErrorCallbackConnector, error_callback));
+          base::BindOnce(&UnregisterErrorCallbackConnector, error_callback));
   provider_.reset();
 }
 

device/bluetooth/bluez/bluetooth_device_bluez.cc

@@ -458,10 +458,10 @@ void BluetoothDeviceBlueZ::GetConnectionInfo(
   // currently connected.
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetConnInfo(
       object_path_,
-      base::Bind(&BluetoothDeviceBlueZ::OnGetConnInfo,
-                 weak_ptr_factory_.GetWeakPtr(), callback),
-      base::Bind(&BluetoothDeviceBlueZ::OnGetConnInfoError,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnGetConnInfo,
+                     weak_ptr_factory_.GetWeakPtr(), callback),
+      base::BindOnce(&BluetoothDeviceBlueZ::OnGetConnInfoError,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BluetoothDeviceBlueZ::SetConnectionLatency(
@@ -499,10 +499,10 @@ void BluetoothDeviceBlueZ::SetConnectionLatency(
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient();
   client->SetLEConnectionParameters(
       object_path_, connection_parameters,
-      base::Bind(&BluetoothDeviceBlueZ::OnSetLEConnectionParameters,
-                 weak_ptr_factory_.GetWeakPtr(), callback),
-      base::Bind(&BluetoothDeviceBlueZ::OnSetLEConnectionParametersError,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnSetLEConnectionParameters,
+                     weak_ptr_factory_.GetWeakPtr(), callback),
+      base::BindOnce(&BluetoothDeviceBlueZ::OnSetLEConnectionParametersError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceBlueZ::Connect(
@@ -556,11 +556,11 @@ void BluetoothDeviceBlueZ::Connect(
 
     bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->Pair(
         object_path_,
-        base::Bind(&BluetoothDeviceBlueZ::OnPairDuringConnect,
-                   weak_ptr_factory_.GetWeakPtr(), dupe_callback,
-                   dupe_error_callback),
-        base::Bind(&BluetoothDeviceBlueZ::OnPairDuringConnectError,
-                   weak_ptr_factory_.GetWeakPtr(), dupe_error_callback));
+        base::BindOnce(&BluetoothDeviceBlueZ::OnPairDuringConnect,
+                       weak_ptr_factory_.GetWeakPtr(), dupe_callback,
+                       dupe_error_callback),
+        base::BindOnce(&BluetoothDeviceBlueZ::OnPairDuringConnectError,
+                       weak_ptr_factory_.GetWeakPtr(), dupe_error_callback));
   }
 }
 
@@ -625,8 +625,8 @@ void BluetoothDeviceBlueZ::CancelPairing() {
                          << "Sending explicit cancel";
     bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->CancelPairing(
         object_path_, base::DoNothing(),
-        base::Bind(&BluetoothDeviceBlueZ::OnCancelPairingError,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::BindOnce(&BluetoothDeviceBlueZ::OnCancelPairingError,
+                       weak_ptr_factory_.GetWeakPtr()));
   }
 
   // Since there is no callback to this method it's possible that the pairing
@@ -641,10 +641,10 @@ void BluetoothDeviceBlueZ::Disconnect(const base::Closure& callback,
   BLUETOOTH_LOG(EVENT) << object_path_.value() << ": Disconnecting";
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->Disconnect(
       object_path_,
-      base::Bind(&BluetoothDeviceBlueZ::OnDisconnect,
-                 weak_ptr_factory_.GetWeakPtr(), callback),
-      base::Bind(&BluetoothDeviceBlueZ::OnDisconnectError,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnDisconnect,
+                     weak_ptr_factory_.GetWeakPtr(), callback),
+      base::BindOnce(&BluetoothDeviceBlueZ::OnDisconnectError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceBlueZ::Forget(const base::Closure& callback,
@@ -652,8 +652,8 @@ void BluetoothDeviceBlueZ::Forget(const base::Closure& callback,
   BLUETOOTH_LOG(EVENT) << object_path_.value() << ": Removing device";
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->RemoveDevice(
       adapter()->object_path(), object_path_, callback,
-      base::Bind(&BluetoothDeviceBlueZ::OnForgetError,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnForgetError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceBlueZ::ConnectToService(
@@ -694,8 +694,8 @@ void BluetoothDeviceBlueZ::GetServiceRecords(
     const GetServiceRecordsErrorCallback& error_callback) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetServiceRecords(
       object_path_, callback,
-      base::Bind(&BluetoothDeviceBlueZ::OnGetServiceRecordsError,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnGetServiceRecordsError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 #if defined(OS_CHROMEOS)
@@ -704,8 +704,8 @@ void BluetoothDeviceBlueZ::ExecuteWrite(
     const ExecuteWriteErrorCallback& error_callback) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ExecuteWrite(
       object_path_, callback,
-      base::Bind(&BluetoothDeviceBlueZ::OnExecuteWriteError,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnExecuteWriteError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceBlueZ::AbortWrite(
@@ -713,8 +713,8 @@ void BluetoothDeviceBlueZ::AbortWrite(
     const AbortWriteErrorCallback& error_callback) {
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->AbortWrite(
       object_path_, callback,
-      base::Bind(&BluetoothDeviceBlueZ::OnAbortWriteError,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+      base::BindOnce(&BluetoothDeviceBlueZ::OnAbortWriteError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 #endif
 
@@ -1076,8 +1076,8 @@ void BluetoothDeviceBlueZ::SetTrusted() {
   bluez::BluezDBusManager::Get()
       ->GetBluetoothDeviceClient()
       ->GetProperties(object_path_)
-      ->trusted.Set(true, base::Bind(&BluetoothDeviceBlueZ::OnSetTrusted,
-                                     weak_ptr_factory_.GetWeakPtr()));
+      ->trusted.Set(true, base::BindOnce(&BluetoothDeviceBlueZ::OnSetTrusted,
+                                         weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothDeviceBlueZ::OnSetTrusted(bool success) {
@@ -1114,10 +1114,10 @@ void BluetoothDeviceBlueZ::OnForgetError(const ErrorCallback& error_callback,
 
 void BluetoothDeviceBlueZ::UnpauseDiscovery() {
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->UnpauseDiscovery(
-      adapter()->object_path(), base::Bind([]() {
+      adapter()->object_path(), base::BindOnce([]() {
         BLUETOOTH_LOG(EVENT) << "Successfully un-paused discovery";
       }),
-      base::Bind(
+      base::BindOnce(
           [](const std::string& error_name, const std::string& error_message) {
             BLUETOOTH_LOG(EVENT) << "Failed to un-pause discovery";
           }));

device/bluetooth/bluez/bluetooth_socket_bluez.cc

@@ -263,10 +263,10 @@ void BluetoothSocketBlueZ::OnRegisterProfile(
 
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
       device_path_, uuid_.canonical_value(),
-      base::Bind(&BluetoothSocketBlueZ::OnConnectProfile, this,
-                 success_callback),
-      base::Bind(&BluetoothSocketBlueZ::OnConnectProfileError, this,
-                 error_callback));
+      base::BindOnce(&BluetoothSocketBlueZ::OnConnectProfile, this,
+                     success_callback),
+      base::BindOnce(&BluetoothSocketBlueZ::OnConnectProfileError, this,
+                     error_callback));
 }
 
 void BluetoothSocketBlueZ::OnRegisterProfileError(