Add support for the audio-output-device switching IPC mechanism to the renderer lower layers (media…

media/audio/audio_output_device.cc

 // Copyright (c) 2012 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 "media/audio/audio_output_device.h"
 
+#include <string>
+
+#include "base/callback_helpers.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 // Takes care of invoking the render callback on the audio thread.
 // An instance of this class is created for each capture stream in
@@ skipping 21 matching lines @@
 
 AudioOutputDevice::AudioOutputDevice(
     scoped_ptr<AudioOutputIPC> ipc,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : ScopedTaskRunnerObserver(io_task_runner),
       callback_(NULL),
       ipc_(ipc.Pass()),
       state_(IDLE),
       play_on_start_(true),
       session_id_(-1),
-      stopping_hack_(false) {
+      stopping_hack_(false),
+      current_switch_request_id_(0) {
   CHECK(ipc_);
 
   // The correctness of the code depends on the relative values assigned in the
   // State enum.
   static_assert(IPC_CLOSED < IDLE, "invalid enum value assignment 0");
   static_assert(IDLE < CREATING_STREAM, "invalid enum value assignment 1");
   static_assert(CREATING_STREAM < PAUSED, "invalid enum value assignment 2");
   static_assert(PAUSED < PLAYING, "invalid enum value assignment 3");
 }
 
 void AudioOutputDevice::InitializeWithSessionId(const AudioParameters& params,
                                                 RenderCallback* callback,
                                                 int session_id) {
   DCHECK(!callback_) << "Calling InitializeWithSessionId() twice?";
   DCHECK(params.IsValid());
   audio_parameters_ = params;
   callback_ = callback;
   session_id_ = session_id;
 }
 
 void AudioOutputDevice::Initialize(const AudioParameters& params,
                                    RenderCallback* callback) {
   InitializeWithSessionId(params, callback, 0);
 }
 
 AudioOutputDevice::~AudioOutputDevice() {
   // The current design requires that the user calls Stop() before deleting
   // this class.
   DCHECK(audio_thread_.IsStopped());
+
+  // The following makes it possible for |current_switch_callback_| to release
+  // its bound parameters in the correct thread instead of implicitly releasing
+  // them in the thread where this destructor runs.
+  if (!current_switch_callback_.is_null()) {
+    base::ResetAndReturn(&current_switch_callback_).Run(
+        SWITCH_OUTPUT_DEVICE_RESULT_ERROR_OBSOLETE);
+  }
 }
 
 void AudioOutputDevice::Start() {
   DCHECK(callback_) << "Initialize hasn't been called";
   task_runner()->PostTask(FROM_HERE,
       base::Bind(&AudioOutputDevice::CreateStreamOnIOThread, this,
                  audio_parameters_));
 }
 
 void AudioOutputDevice::Stop() {
@@ skipping 22 matching lines @@
     return false;
 
   if (!task_runner()->PostTask(FROM_HERE,
           base::Bind(&AudioOutputDevice::SetVolumeOnIOThread, this, volume))) {
     return false;
   }
 
   return true;
 }
 
+void AudioOutputDevice::SwitchOutputDevice(
+    const std::string& device_id,
+    const GURL& security_origin,
+    const SwitchOutputDeviceCB& callback) {
+  DVLOG(1) << __FUNCTION__ << "(" << device_id << ")";
+  task_runner()->PostTask(
+      FROM_HERE, base::Bind(&AudioOutputDevice::SwitchOutputDeviceOnIOThread,
+                            this, device_id, security_origin, callback));
+}
+
 void AudioOutputDevice::CreateStreamOnIOThread(const AudioParameters& params) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   if (state_ == IDLE) {
     state_ = CREATING_STREAM;
     ipc_->CreateStream(this, params, session_id_);
   }
 }
 
 void AudioOutputDevice::PlayOnIOThread() {
   DCHECK(task_runner()->BelongsToCurrentThread());
@@ skipping 42 matching lines @@
   audio_callback_.reset();
   stopping_hack_ = false;
 }
 
 void AudioOutputDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   if (state_ >= CREATING_STREAM)
     ipc_->SetVolume(volume);
 }
 
+void AudioOutputDevice::SwitchOutputDeviceOnIOThread(
+    const std::string& device_id,
+    const GURL& security_origin,
+    const SwitchOutputDeviceCB& callback) {
+  DCHECK(task_runner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__ << "(" << device_id << "," << security_origin << ")";
+  if (state_ >= CREATING_STREAM) {
+    SetCurrentSwitchRequest(callback);
+    ipc_->SwitchOutputDevice(device_id, security_origin,
+                             current_switch_request_id_);
+  } else {
+    callback.Run(SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_SUPPORTED);
+  }
+}
+
 void AudioOutputDevice::OnStateChanged(AudioOutputIPCDelegateState state) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
   if (state_ < CREATING_STREAM)
     return;
 
   // TODO(miu): Clean-up inconsistent and incomplete handling here.
   // http://crbug.com/180640
   switch (state) {
@@ skipping 55 matching lines @@
   audio_thread_.Start(
       audio_callback_.get(), socket_handle, "AudioOutputDevice", true);
   state_ = PAUSED;
 
   // We handle the case where Play() and/or Pause() may have been called
   // multiple times before OnStreamCreated() gets called.
   if (play_on_start_)
     PlayOnIOThread();
 }
 
+void AudioOutputDevice::SetCurrentSwitchRequest(
+    const SwitchOutputDeviceCB& callback) {
+  DCHECK(task_runner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+  // If there is a previous unresolved request, resolve it as obsolete
+  if (!current_switch_callback_.is_null()) {
+    base::ResetAndReturn(&current_switch_callback_).Run(
+        SWITCH_OUTPUT_DEVICE_RESULT_ERROR_OBSOLETE);
+  }
+  current_switch_callback_ = callback;
+  current_switch_request_id_++;
+}
+
+void AudioOutputDevice::OnOutputDeviceSwitched(
+    int request_id,
+    SwitchOutputDeviceResult result) {
+  DCHECK(task_runner()->BelongsToCurrentThread());
+  DCHECK(request_id <= current_switch_request_id_);
+  DVLOG(1) << __FUNCTION__
+           << "(" << request_id << ", " << result << ")";
+  if (request_id != current_switch_request_id_) {
+    return;
+  }
+  base::ResetAndReturn(&current_switch_callback_).Run(result);
+}
+
 void AudioOutputDevice::OnIPCClosed() {
   DCHECK(task_runner()->BelongsToCurrentThread());
   state_ = IPC_CLOSED;
   ipc_.reset();
 }
 
 void AudioOutputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the audio device has been stopped";
   ShutDownOnIOThread();
 }
@@ skipping 37 matching lines @@
     TRACE_EVENT_ASYNC_END0("audio", "StartingPlayback", this);
   }
 
   // Update the audio-delay measurement then ask client to render audio.  Since
   // |output_bus_| is wrapping the shared memory the Render() call is writing
   // directly into the shared memory.
   render_callback_->Render(output_bus_.get(), audio_delay_milliseconds);
 }
 
 }  // namespace media.