Allow AudioOutputDevice objects to be initialized with a specific hardware output device and store …

content/renderer/media/audio_message_filter.cc

Index: content/renderer/media/audio_message_filter.cc
diff --git a/content/renderer/media/audio_message_filter.cc b/content/renderer/media/audio_message_filter.cc
index f37b21cf927986c792f04a118f24f7f3a0937578..3e2629ce126f022f1625e43d603e293b5785371a 100644
--- a/content/renderer/media/audio_message_filter.cc
+++ b/content/renderer/media/audio_message_filter.cc
@@ -28,21 +28,24 @@ class AudioMessageFilter::AudioOutputIPCImpl
   ~AudioOutputIPCImpl() override;
 
   // media::AudioOutputIPC implementation.
+  void RequestDeviceAuthorization(media::AudioOutputIPCDelegate* delegate,
+                                  int session_id,
+                                  const std::string& device_id,
+                                  const GURL& security_origin) override;
   void CreateStream(media::AudioOutputIPCDelegate* delegate,
-                    const media::AudioParameters& params,
-                    int session_id) override;
+                    const media::AudioParameters& params) override;
   void PlayStream() override;
   void PauseStream() override;
   void CloseStream() override;
   void SetVolume(double volume) override;
   void SwitchOutputDevice(const std::string& device_id,
-                          const GURL& security_origin,
-                          int request_id) override;
+                          const GURL& security_origin) override;
 
  private:
   const scoped_refptr<AudioMessageFilter> filter_;
   const int render_frame_id_;
   int stream_id_;
+  bool stream_created_;
 };
 
 AudioMessageFilter* AudioMessageFilter::g_filter = NULL;
@@ -69,7 +72,8 @@ AudioMessageFilter::AudioOutputIPCImpl::AudioOutputIPCImpl(
     int render_frame_id)
     : filter_(filter),
       render_frame_id_(render_frame_id),
-      stream_id_(kStreamIDNotSet) {}
+      stream_id_(kStreamIDNotSet),
+      stream_created_(false) {}
 
 AudioMessageFilter::AudioOutputIPCImpl::~AudioOutputIPCImpl() {}
 
@@ -80,25 +84,41 @@ scoped_ptr<media::AudioOutputIPC> AudioMessageFilter::CreateAudioOutputIPC(
       new AudioOutputIPCImpl(this, render_frame_id));
 }
 
-void AudioMessageFilter::AudioOutputIPCImpl::CreateStream(
+void AudioMessageFilter::AudioOutputIPCImpl::RequestDeviceAuthorization(
     media::AudioOutputIPCDelegate* delegate,
-    const media::AudioParameters& params,
-    int session_id) {
+    int session_id,
+    const std::string& device_id,
+    const GURL& security_origin) {
   DCHECK(filter_->io_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate);
   DCHECK_EQ(stream_id_, kStreamIDNotSet);
+  DCHECK(!stream_created_);
+
   stream_id_ = filter_->delegates_.Add(delegate);
-  filter_->Send(new AudioHostMsg_CreateStream(stream_id_, render_frame_id_,
-                                              session_id, params));
+  filter_->Send(new AudioHostMsg_RequestDeviceAuthorization(
+      stream_id_, render_frame_id_, session_id, device_id, security_origin));
+}
+
+void AudioMessageFilter::AudioOutputIPCImpl::CreateStream(
+    media::AudioOutputIPCDelegate* delegate,
+    const media::AudioParameters& params) {
+  DCHECK(filter_->io_task_runner_->BelongsToCurrentThread());
+  DCHECK(!stream_created_);
+  if (stream_id_ == kStreamIDNotSet)
+    stream_id_ = filter_->delegates_.Add(delegate);
+
+  filter_->Send(
+      new AudioHostMsg_CreateStream(stream_id_, render_frame_id_, params));
+  stream_created_ = true;
 }
 
 void AudioMessageFilter::AudioOutputIPCImpl::PlayStream() {
-  DCHECK_NE(stream_id_, kStreamIDNotSet);
+  DCHECK(stream_created_);
   filter_->Send(new AudioHostMsg_PlayStream(stream_id_));
 }
 
 void AudioMessageFilter::AudioOutputIPCImpl::PauseStream() {
-  DCHECK_NE(stream_id_, kStreamIDNotSet);
+  DCHECK(stream_created_);
   filter_->Send(new AudioHostMsg_PauseStream(stream_id_));
 }
 
@@ -108,22 +128,20 @@ void AudioMessageFilter::AudioOutputIPCImpl::CloseStream() {
   filter_->Send(new AudioHostMsg_CloseStream(stream_id_));
   filter_->delegates_.Remove(stream_id_);
   stream_id_ = kStreamIDNotSet;
+  stream_created_ = false;
 }
 
 void AudioMessageFilter::AudioOutputIPCImpl::SetVolume(double volume) {
-  DCHECK_NE(stream_id_, kStreamIDNotSet);
+  DCHECK(stream_created_);
   filter_->Send(new AudioHostMsg_SetVolume(stream_id_, volume));
 }
 
 void AudioMessageFilter::AudioOutputIPCImpl::SwitchOutputDevice(
     const std::string& device_id,
-    const GURL& security_origin,
-    int request_id) {
-  DCHECK_NE(stream_id_, kStreamIDNotSet);
-  DVLOG(1) << __FUNCTION__
-           << "(" << device_id << ", " << security_origin << ")";
+    const GURL& security_origin) {
+  DCHECK(stream_created_);
   filter_->Send(new AudioHostMsg_SwitchOutputDevice(
-      stream_id_, render_frame_id_, device_id, security_origin, request_id));
+      stream_id_, render_frame_id_, device_id, security_origin));
 }
 
 void AudioMessageFilter::Send(IPC::Message* message) {
@@ -139,6 +157,7 @@ bool AudioMessageFilter::OnMessageReceived(const IPC::Message& message) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AudioMessageFilter, message)
+    IPC_MESSAGE_HANDLER(AudioMsg_NotifyDeviceAuthorized, OnDeviceAuthorized)
     IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamCreated, OnStreamCreated)
     IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamStateChanged, OnStreamStateChanged)
     IPC_MESSAGE_HANDLER(AudioMsg_NotifyOutputDeviceSwitched,
@@ -176,6 +195,20 @@ void AudioMessageFilter::OnChannelClosing() {
   }
 }
 
+void AudioMessageFilter::OnDeviceAuthorized(
+    int stream_id,
+    bool success,
+    const media::AudioParameters& output_params) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  media::AudioOutputIPCDelegate* delegate = delegates_.Lookup(stream_id);
+  if (!delegate) {
+    DLOG(WARNING) << "Got OnDeviceAuthorized() event for a nonexistent or"

[DaleCurtis, 2015/09/12 01:17:19]

Seems like this could happen when devices are shutdown? Do we want to log a
warning here?

[Guido Urdaneta, 2015/09/14 11:35:48]

Done. It was there for consistency with the other AMF methods, which have this
warning.

+                  << " removed audio renderer (stream_id=" << stream_id << ").";
+    return;
+  }
+  delegate->OnDeviceAuthorized(success, output_params);
+}
+
 void AudioMessageFilter::OnStreamCreated(
     int stream_id,
     base::SharedMemoryHandle handle,
@@ -215,18 +248,16 @@ void AudioMessageFilter::OnStreamStateChanged(
 
 void AudioMessageFilter::OnOutputDeviceSwitched(
     int stream_id,
-    int request_id,
-    media::SwitchOutputDeviceResult result) {
+    media::SwitchOutputDeviceResult result,
+    const media::AudioParameters& output_params) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__
-           << "(" << stream_id << ", " << request_id << ", " << result << ")";
   media::AudioOutputIPCDelegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "Got OnOutputDeviceSwitched() event for a nonexistent or"
                   << " removed audio renderer.  State: " << result;
     return;
   }
-  delegate->OnOutputDeviceSwitched(request_id, result);
+  delegate->OnOutputDeviceSwitched(result, output_params);
 }
 
 }  // namespace content