Migrate CrasAudioClient to use DBusMethodCallback.

BUG=739622
TEST=Ran trybots.

Change-Id: I6b2d0fc454c6915449c3955b83c5b954119b0626
Reviewed-on: https://chromium-review.googlesource.com/768928Reviewed-by: Dan Erat <derat@chromium.org>
Commit-Queue: Hidehiko Abe <hidehiko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#517894}

chromeos/audio/cras_audio_handler.cc

@@ -1655,14 +1655,14 @@ void CrasAudioHandler::GetDefaultOutputBufferSizeInternal() {
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void CrasAudioHandler::HandleGetDefaultOutputBufferSize(int32_t buffer_size,
-                                                        bool success) {
-  if (!success) {
+void CrasAudioHandler::HandleGetDefaultOutputBufferSize(
+    base::Optional<int> buffer_size) {
+  if (!buffer_size.has_value()) {
     LOG(ERROR) << "Failed to retrieve output buffer size";
     return;
   }
 
-  default_output_buffer_size_ = buffer_size;
+  default_output_buffer_size_ = buffer_size.value();
 }
 
 }  // namespace chromeos

chromeos/audio/cras_audio_handler.h

@@ -472,7 +472,7 @@ class CHROMEOS_EXPORT CrasAudioHandler : public CrasAudioClient::Observer,
   void GetDefaultOutputBufferSizeInternal();
 
   // Handle dbus callback for GetDefaultOutputBufferSize.
-  void HandleGetDefaultOutputBufferSize(int buffer_size, bool success);
+  void HandleGetDefaultOutputBufferSize(base::Optional<int> buffer_size);
 
   void OnVideoCaptureStartedOnMainThread(media::VideoFacingMode facing);
   void OnVideoCaptureStoppedOnMainThread(media::VideoFacingMode facing);

chromeos/dbus/cras_audio_client.cc

@@ -40,23 +40,22 @@ class CrasAudioClientImpl : public CrasAudioClient {
     return observers_.HasObserver(observer);
   }
 
-  void GetVolumeState(const GetVolumeStateCallback& callback) override {
+  void GetVolumeState(DBusMethodCallback<VolumeState> callback) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kGetVolumeState);
     cras_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::BindOnce(&CrasAudioClientImpl::OnGetVolumeState,
-                       weak_ptr_factory_.GetWeakPtr(), callback));
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
   }
 
-  void GetDefaultOutputBufferSize(
-      const GetDefaultOutputBufferSizeCallback& callback) override {
+  void GetDefaultOutputBufferSize(DBusMethodCallback<int> callback) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kGetDefaultOutputBufferSize);
     cras_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::BindOnce(&CrasAudioClientImpl::OnGetDefaultOutputBufferSize,
-                       weak_ptr_factory_.GetWeakPtr(), callback));
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
   }
 
   void GetNodes(DBusMethodCallback<AudioNodeList> callback) override {
@@ -379,48 +378,47 @@ class CrasAudioClientImpl : public CrasAudioClient {
       observer.HotwordTriggered(tv_sec, tv_nsec);
   }
 
-  void OnGetVolumeState(const GetVolumeStateCallback& callback,
+  void OnGetVolumeState(DBusMethodCallback<VolumeState> callback,
                         dbus::Response* response) {
-    bool success = true;
-    VolumeState volume_state;
-    if (response) {
-      dbus::MessageReader reader(response);
-      if (!reader.PopInt32(&volume_state.output_volume) ||
-          !reader.PopBool(&volume_state.output_system_mute) ||
-          !reader.PopInt32(&volume_state.input_gain) ||
-          !reader.PopBool(&volume_state.input_mute) ||
-          !reader.PopBool(&volume_state.output_user_mute)) {
-        success = false;
-        LOG(ERROR) << "Error reading response from cras: "
-                   << response->ToString();
-      }
-    } else {
-      success = false;
+    if (!response) {
       LOG(ERROR) << "Error calling " << cras::kGetVolumeState;
+      std::move(callback).Run(base::nullopt);
+      return;
     }
 
-    callback.Run(volume_state, success);
-  }
+    VolumeState volume_state;
+    dbus::MessageReader reader(response);
+    if (!reader.PopInt32(&volume_state.output_volume) ||
+        !reader.PopBool(&volume_state.output_system_mute) ||
+        !reader.PopInt32(&volume_state.input_gain) ||
+        !reader.PopBool(&volume_state.input_mute) ||
+        !reader.PopBool(&volume_state.output_user_mute)) {
+      LOG(ERROR) << "Error reading response from cras: "
+                 << response->ToString();
+      std::move(callback).Run(base::nullopt);
+      return;
+    }
 
-  void OnGetDefaultOutputBufferSize(
-      const GetDefaultOutputBufferSizeCallback& callback,
-      dbus::Response* response) {
-    bool success = true;
-    int32_t buffer_size = 0;
+    std::move(callback).Run(std::move(volume_state));
+  }
 
-    if (response) {
-      dbus::MessageReader reader(response);
-      if (!reader.PopInt32(&buffer_size)) {
-        success = false;
-        LOG(ERROR) << "Error reading response from cras: "
-                   << response->ToString();
-      }
-    } else {
-      success = false;
+  void OnGetDefaultOutputBufferSize(DBusMethodCallback<int> callback,
+                                    dbus::Response* response) {
+    if (!response) {
       LOG(ERROR) << "Error calling " << cras::kGetDefaultOutputBufferSize;
+      std::move(callback).Run(base::nullopt);
+      return;
+    }
+    int32_t buffer_size = 0;
+    dbus::MessageReader reader(response);
+    if (!reader.PopInt32(&buffer_size)) {
+      LOG(ERROR) << "Error reading response from cras: "
+                 << response->ToString();
+      std::move(callback).Run(base::nullopt);
+      return;
     }
 
-    callback.Run(buffer_size, success);
+    std::move(callback).Run(buffer_size);
   }
 
   void OnGetNodes(DBusMethodCallback<AudioNodeList> callback,

chromeos/dbus/cras_audio_client.h

@@ -64,24 +64,11 @@ class CHROMEOS_EXPORT CrasAudioClient : public DBusClient {
   // Returns true if this object has the given observer.
   virtual bool HasObserver(const Observer* observer) const = 0;
 
-  // GetVolumeStateCallback is used for GetVolumeState method. It receives
-  // 2 arguments, |volume_state| which containing both input and  output volume
-  // state data, and |success| which indicates whether or not the request
-  // succeeded.
-  typedef base::Callback<void(const VolumeState&, bool)> GetVolumeStateCallback;
-
-  // Used for GetDefaultOutputBufferSize method. The first argument is the
-  // default output buffer size. The second argument indicates whether the
-  // request succeeded. The first argument is valid only when the request
-  // succeeded.
-  typedef base::Callback<void(int, bool)> GetDefaultOutputBufferSizeCallback;
-
   // Gets the volume state, asynchronously.
-  virtual void GetVolumeState(const GetVolumeStateCallback& callback) = 0;
+  virtual void GetVolumeState(DBusMethodCallback<VolumeState> callback) = 0;
 
   // Gets the default output buffer size in frames.
-  virtual void GetDefaultOutputBufferSize(
-      const GetDefaultOutputBufferSizeCallback& callback) = 0;
+  virtual void GetDefaultOutputBufferSize(DBusMethodCallback<int> callback) = 0;
 
   // Gets an array of audio input and output nodes.
   virtual void GetNodes(DBusMethodCallback<AudioNodeList> callback) = 0;

chromeos/dbus/fake_cras_audio_client.cc

@@ -98,13 +98,13 @@ bool FakeCrasAudioClient::HasObserver(const Observer* observer) const {
 }
 
 void FakeCrasAudioClient::GetVolumeState(
-    const GetVolumeStateCallback& callback) {
-  callback.Run(volume_state_, true);
+    DBusMethodCallback<VolumeState> callback) {
+  std::move(callback).Run(volume_state_);
 }
 
 void FakeCrasAudioClient::GetDefaultOutputBufferSize(
-    const GetDefaultOutputBufferSizeCallback& callback) {
-  callback.Run(512, true);
+    DBusMethodCallback<int> callback) {
+  std::move(callback).Run(512);
 }
 
 void FakeCrasAudioClient::GetNodes(DBusMethodCallback<AudioNodeList> callback) {

chromeos/dbus/fake_cras_audio_client.h

@@ -26,9 +26,8 @@ class CHROMEOS_EXPORT FakeCrasAudioClient : public CrasAudioClient {
   void AddObserver(Observer* observer) override;
   void RemoveObserver(Observer* observer) override;
   bool HasObserver(const Observer* observer) const override;
-  void GetVolumeState(const GetVolumeStateCallback& callback) override;
-  void GetDefaultOutputBufferSize(
-      const GetDefaultOutputBufferSizeCallback& callback) override;
+  void GetVolumeState(DBusMethodCallback<VolumeState> callback) override;
+  void GetDefaultOutputBufferSize(DBusMethodCallback<int> callback) override;
   void GetNodes(DBusMethodCallback<AudioNodeList> callback) override;
   void SetOutputNodeVolume(uint64_t node_id, int32_t volume) override;
   void SetOutputUserMute(bool mute_on) override;