Convert Callbacks to OnceCallbacks in BluetoothLEAdvertisingManagerClient

This will allow us to convert more Callbacks in the bluetooth component
over to OnceCallbacks, which will let us convert Callbacks in content
eventually.

R=reillyg@chromium.org

Bug: 953861
Change-Id: Ibdc6523432ff74ff265e3086c4a8580a88b3e52c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1572999
Commit-Queue: danakj <danakj@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#652265}

device/bluetooth/dbus/bluetooth_le_advertising_manager_client.cc

@@ -60,8 +60,8 @@ class BluetoothAdvertisementManagerClientImpl
   // BluetoothAdvertisementManagerClient override.
   void RegisterAdvertisement(const dbus::ObjectPath& manager_object_path,
                              const dbus::ObjectPath& advertisement_object_path,
-                             const base::Closure& callback,
-                             const ErrorCallback& error_callback) override {
+                             base::OnceClosure callback,
+                             ErrorCallback error_callback) override {
     dbus::MethodCall method_call(
         bluetooth_advertising_manager::kBluetoothAdvertisingManagerInterface,
         bluetooth_advertising_manager::kRegisterAdvertisement);
@@ -74,16 +74,16 @@ class BluetoothAdvertisementManagerClientImpl
     writer.OpenArray("{sv}", &array_writer);
     writer.CloseContainer(&array_writer);
 
-    CallObjectProxyMethod(manager_object_path, &method_call, callback,
-                          error_callback);
+    CallObjectProxyMethod(manager_object_path, &method_call,
+                          std::move(callback), std::move(error_callback));
   }
 
   // BluetoothAdvertisementManagerClient override.
   void UnregisterAdvertisement(
       const dbus::ObjectPath& manager_object_path,
       const dbus::ObjectPath& advertisement_object_path,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) override {
+      base::OnceClosure callback,
+      ErrorCallback error_callback) override {
     dbus::MethodCall method_call(
         bluetooth_advertising_manager::kBluetoothAdvertisingManagerInterface,
         bluetooth_advertising_manager::kUnregisterAdvertisement);
@@ -91,15 +91,15 @@ class BluetoothAdvertisementManagerClientImpl
     dbus::MessageWriter writer(&method_call);
     writer.AppendObjectPath(advertisement_object_path);
 
-    CallObjectProxyMethod(manager_object_path, &method_call, callback,
-                          error_callback);
+    CallObjectProxyMethod(manager_object_path, &method_call,
+                          std::move(callback), std::move(error_callback));
   }
 
   void SetAdvertisingInterval(const dbus::ObjectPath& manager_object_path,
                               uint16_t min_interval_ms,
                               uint16_t max_interval_ms,
-                              const base::Closure& callback,
-                              const ErrorCallback& error_callback) override {
+                              base::OnceClosure callback,
+                              ErrorCallback error_callback) override {
     dbus::MethodCall method_call(
         bluetooth_advertising_manager::kBluetoothAdvertisingManagerInterface,
         bluetooth_advertising_manager::kSetAdvertisingIntervals);
@@ -108,19 +108,19 @@ class BluetoothAdvertisementManagerClientImpl
     writer.AppendUint16(min_interval_ms);
     writer.AppendUint16(max_interval_ms);
 
-    CallObjectProxyMethod(manager_object_path, &method_call, callback,
-                          error_callback);
+    CallObjectProxyMethod(manager_object_path, &method_call,
+                          std::move(callback), std::move(error_callback));
   }
 
   void ResetAdvertising(const dbus::ObjectPath& manager_object_path,
-                        const base::Closure& callback,
-                        const ErrorCallback& error_callback) override {
+                        base::OnceClosure callback,
+                        ErrorCallback error_callback) override {
     dbus::MethodCall method_call(
         bluetooth_advertising_manager::kBluetoothAdvertisingManagerInterface,
         bluetooth_advertising_manager::kResetAdvertising);
 
-    CallObjectProxyMethod(manager_object_path, &method_call, callback,
-                          error_callback);
+    CallObjectProxyMethod(manager_object_path, &method_call,
+                          std::move(callback), std::move(error_callback));
   }
 
  protected:
@@ -141,23 +141,25 @@ class BluetoothAdvertisementManagerClientImpl
   // if the bluetooth adapter exists and run error callback if it doesn't.
   void CallObjectProxyMethod(const dbus::ObjectPath& manager_object_path,
                              dbus::MethodCall* method_call,
-                             const base::Closure& callback,
-                             const ErrorCallback& error_callback) {
+                             base::OnceClosure callback,
+                             ErrorCallback error_callback) {
     DCHECK(object_manager_);
     dbus::ObjectProxy* object_proxy =
         object_manager_->GetObjectProxy(manager_object_path);
     if (!object_proxy) {
-      error_callback.Run(bluetooth_advertising_manager::kErrorFailed,
-                         "Adapter does not exist.");
+      std::move(error_callback)
+          .Run(bluetooth_advertising_manager::kErrorFailed,
+               "Adapter does not exist.");
       return;
     }
 
     object_proxy->CallMethodWithErrorCallback(
         method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::BindOnce(&BluetoothAdvertisementManagerClientImpl::OnSuccess,
-                       weak_ptr_factory_.GetWeakPtr(), callback),
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)),
         base::BindOnce(&BluetoothAdvertisementManagerClientImpl::OnError,
-                       weak_ptr_factory_.GetWeakPtr(), error_callback));
+                       weak_ptr_factory_.GetWeakPtr(),
+                       std::move(error_callback)));
   }
 
   // Called by dbus::ObjectManager when an object with the advertising manager
@@ -177,14 +179,13 @@ class BluetoothAdvertisementManagerClientImpl
   }
 
   // Called when a response for successful method call is received.
-  void OnSuccess(const base::Closure& callback, dbus::Response* response) {
+  void OnSuccess(base::OnceClosure callback, dbus::Response* response) {
     DCHECK(response);
-    callback.Run();
+    std::move(callback).Run();
   }
 
   // Called when a response for a failed method call is received.
-  void OnError(const ErrorCallback& error_callback,
-               dbus::ErrorResponse* response) {
+  void OnError(ErrorCallback error_callback, dbus::ErrorResponse* response) {
     // Error response has optional error message argument.
     std::string error_name;
     std::string error_message;
@@ -196,7 +197,7 @@ class BluetoothAdvertisementManagerClientImpl
       error_name = kNoResponseError;
       error_message = "";
     }
-    error_callback.Run(error_name, error_message);
+    std::move(error_callback).Run(error_name, error_message);
   }
 
   dbus::ObjectManager* object_manager_;

device/bluetooth/dbus/bluetooth_le_advertising_manager_client.h

@@ -49,37 +49,38 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothLEAdvertisingManagerClient
   // The ErrorCallback is used by advertising manager methods to indicate
   // failure. It receives two arguments: the name of the error in |error_name|
   // and an optional message in |error_message|.
-  using ErrorCallback = base::Callback<void(const std::string& error_name,
-                                            const std::string& error_message)>;
+  using ErrorCallback =
+      base::OnceCallback<void(const std::string& error_name,
+                              const std::string& error_message)>;
 
   // Registers an advertisement with the DBus object path
   // |advertisement_object_path| with BlueZ's advertising manager.
   virtual void RegisterAdvertisement(
       const dbus::ObjectPath& manager_object_path,
       const dbus::ObjectPath& advertisement_object_path,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) = 0;
+      base::OnceClosure callback,
+      ErrorCallback error_callback) = 0;
 
   // Unregisters an advertisement with the DBus object path
   // |advertisement_object_path| with BlueZ's advertising manager.
   virtual void UnregisterAdvertisement(
       const dbus::ObjectPath& manager_object_path,
       const dbus::ObjectPath& advertisement_object_path,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) = 0;
+      base::OnceClosure callback,
+      ErrorCallback error_callback) = 0;
 
   // Set's the advertising interval.
   virtual void SetAdvertisingInterval(
       const dbus::ObjectPath& manager_object_path,
       uint16_t min_interval_ms,
       uint16_t max_interval_ms,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) = 0;
+      base::OnceClosure callback,
+      ErrorCallback error_callback) = 0;
 
   // Resets advertising.
   virtual void ResetAdvertising(const dbus::ObjectPath& manager_object_path,
-                                const base::Closure& callback,
-                                const ErrorCallback& error_callback) = 0;
+                                base::OnceClosure callback,
+                                ErrorCallback error_callback) = 0;
 
   // Creates the instance.
   static BluetoothLEAdvertisingManagerClient* Create();

device/bluetooth/dbus/fake_bluetooth_le_advertising_manager_client.cc

@@ -43,37 +43,42 @@ void FakeBluetoothLEAdvertisingManagerClient::RemoveObserver(
 void FakeBluetoothLEAdvertisingManagerClient::RegisterAdvertisement(
     const dbus::ObjectPath& manager_object_path,
     const dbus::ObjectPath& advertisement_object_path,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
   VLOG(1) << "RegisterAdvertisment: " << advertisement_object_path.value();
 
   if (manager_object_path != dbus::ObjectPath(kAdvertisingManagerPath)) {
-    error_callback.Run(kNoResponseError, "Invalid Advertising Manager path.");
+    std::move(error_callback)
+        .Run(kNoResponseError, "Invalid Advertising Manager path.");
     return;
   }
 
   auto iter = service_provider_map_.find(advertisement_object_path);
   if (iter == service_provider_map_.end()) {
-    error_callback.Run(bluetooth_advertising_manager::kErrorInvalidArguments,
-                       "Advertisement object not registered");
+    std::move(error_callback)
+        .Run(bluetooth_advertising_manager::kErrorInvalidArguments,
+             "Advertisement object not registered");
   } else if (currently_registered_.size() >= kMaxBluezAdvertisements) {
-    error_callback.Run(bluetooth_advertising_manager::kErrorFailed,
-                       "Maximum advertisements reached");
+    std::move(error_callback)
+        .Run(bluetooth_advertising_manager::kErrorFailed,
+             "Maximum advertisements reached");
   } else {
     currently_registered_.push_back(advertisement_object_path);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  std::move(callback));
   }
 }
 
 void FakeBluetoothLEAdvertisingManagerClient::UnregisterAdvertisement(
     const dbus::ObjectPath& manager_object_path,
     const dbus::ObjectPath& advertisement_object_path,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
   VLOG(1) << "UnregisterAdvertisment: " << advertisement_object_path.value();
 
   if (manager_object_path != dbus::ObjectPath(kAdvertisingManagerPath)) {
-    error_callback.Run(kNoResponseError, "Invalid Advertising Manager path.");
+    std::move(error_callback)
+        .Run(kNoResponseError, "Invalid Advertising Manager path.");
     return;
   }
 
@@ -83,14 +88,17 @@ void FakeBluetoothLEAdvertisingManagerClient::UnregisterAdvertisement(
                 advertisement_object_path);
 
   if (service_iter == service_provider_map_.end()) {
-    error_callback.Run(bluetooth_advertising_manager::kErrorDoesNotExist,
-                       "Advertisement not registered");
+    std::move(error_callback)
+        .Run(bluetooth_advertising_manager::kErrorDoesNotExist,
+             "Advertisement not registered");
   } else if (reg_iter == currently_registered_.end()) {
-    error_callback.Run(bluetooth_advertising_manager::kErrorDoesNotExist,
-                       "Does not exist");
+    std::move(error_callback)
+        .Run(bluetooth_advertising_manager::kErrorDoesNotExist,
+             "Does not exist");
   } else {
     currently_registered_.erase(reg_iter);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  std::move(callback));
   }
 }
 
@@ -98,24 +106,25 @@ void FakeBluetoothLEAdvertisingManagerClient::SetAdvertisingInterval(
     const dbus::ObjectPath& object_path,
     uint16_t min_interval_ms,
     uint16_t max_interval_ms,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
   if (min_interval_ms < kMinIntervalMs || max_interval_ms > kMaxIntervalMs ||
       min_interval_ms > max_interval_ms) {
-    error_callback.Run(bluetooth_advertising_manager::kErrorInvalidArguments,
-                       "Invalid interval.");
+    std::move(error_callback)
+        .Run(bluetooth_advertising_manager::kErrorInvalidArguments,
+             "Invalid interval.");
     return;
   }
-  callback.Run();
+  std::move(callback).Run();
 }
 
 void FakeBluetoothLEAdvertisingManagerClient::ResetAdvertising(
     const dbus::ObjectPath& object_path,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+    base::OnceClosure callback,
+    ErrorCallback error_callback) {
   currently_registered_.clear();
   service_provider_map_.clear();
-  callback.Run();
+  std::move(callback).Run();
 }
 
 void FakeBluetoothLEAdvertisingManagerClient::

device/bluetooth/dbus/fake_bluetooth_le_advertising_manager_client.h

@@ -39,23 +39,23 @@ class DEVICE_BLUETOOTH_EXPORT FakeBluetoothLEAdvertisingManagerClient
   void RemoveObserver(Observer* observer) override;
   void RegisterAdvertisement(const dbus::ObjectPath& manager_object_path,
                              const dbus::ObjectPath& advertisement_object_path,
-                             const base::Closure& callback,
-                             const ErrorCallback& error_callback) override;
+                             base::OnceClosure callback,
+                             ErrorCallback error_callback) override;
   void UnregisterAdvertisement(
       const dbus::ObjectPath& manager_object_path,
       const dbus::ObjectPath& advertisement_object_path,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) override;
+      base::OnceClosure callback,
+      ErrorCallback error_callback) override;
 
   void SetAdvertisingInterval(const dbus::ObjectPath& manager_object_path,
                               uint16_t min_interval_ms,
                               uint16_t max_interval_ms,
-                              const base::Closure& callback,
-                              const ErrorCallback& error_callback) override;
+                              base::OnceClosure callback,
+                              ErrorCallback error_callback) override;
 
   void ResetAdvertising(const dbus::ObjectPath& manager_object_path,
-                        const base::Closure& callback,
-                        const ErrorCallback& error_callback) override;
+                        base::OnceClosure callback,
+                        ErrorCallback error_callback) override;
 
   // Register, unregister and retrieve pointers to profile server providers.
   void RegisterAdvertisementServiceProvider(