Moving SwitchOutputDevice out of OutputDevice interface, eliminating OutputDevice

content/renderer/media/webrtc_audio_renderer.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 "content/renderer/media/webrtc_audio_renderer.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
+#include "media/base/audio_capturer_source.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 #include "third_party/webrtc/media/base/audiorenderer.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "media/audio/win/core_audio_util_win.h"
 #endif
 
 namespace content {
@@ skipping 78 matching lines @@
     delegate_->Stop();
   }
 
   void SetVolume(float volume) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(volume >= 0.0f && volume <= 1.0f);
     playing_state_.set_volume(volume);
     on_play_state_changed_.Run(media_stream_, &playing_state_);
   }
 
-  media::OutputDevice* GetOutputDevice() override {
+  media::OutputDeviceInfo GetOutputDeviceInfo() override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    return delegate_->GetOutputDevice();
+    return delegate_->GetOutputDeviceInfo();
+  }
+
+  void SwitchOutputDevice(
+      const std::string& device_id,
+      const url::Origin& security_origin,
+      const media::OutputDeviceStatusCB& callback) override {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    return delegate_->SwitchOutputDevice(device_id, security_origin, callback);
   }
 
   base::TimeDelta GetCurrentRenderTime() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return delegate_->GetCurrentRenderTime();
   }
 
   bool IsLocalRenderer() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return delegate_->IsLocalRenderer();
@@ skipping 83 matching lines @@
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, UNINITIALIZED);
     DCHECK(!source_);
   }
 
   sink_ = AudioDeviceFactory::NewAudioRendererSink(
       AudioDeviceFactory::kSourceWebRtc, source_render_frame_id_, session_id_,
       output_device_id_, security_origin_);
 
-  if (sink_->GetOutputDevice()->GetDeviceStatus() !=
+  if (sink_->GetOutputDeviceInfo().device_status() !=
       media::OUTPUT_DEVICE_STATUS_OK) {
     return false;
   }
 
   PrepareSink();
   {
     // No need to reassert the preconditions because the other thread accessing
     // the fields (checked by |audio_renderer_thread_checker_|) only reads them.
     base::AutoLock auto_lock(lock_);
     source_ = source;
@@ skipping 110 matching lines @@
 }
 
 void WebRtcAudioRenderer::SetVolume(float volume) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(volume >= 0.0f && volume <= 1.0f);
 
   playing_state_.set_volume(volume);
   OnPlayStateChanged(media_stream_, &playing_state_);
 }
 
-media::OutputDevice* WebRtcAudioRenderer::GetOutputDevice() {
+media::OutputDeviceInfo WebRtcAudioRenderer::GetOutputDeviceInfo() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return this;
+  return sink_ ? sink_->GetOutputDeviceInfo() : media::OutputDeviceInfo();
 }
 
 base::TimeDelta WebRtcAudioRenderer::GetCurrentRenderTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   return current_time_;
 }
 
 bool WebRtcAudioRenderer::IsLocalRenderer() const {
   return false;
 }
 
 void WebRtcAudioRenderer::SwitchOutputDevice(
     const std::string& device_id,
     const url::Origin& security_origin,
-    const media::SwitchOutputDeviceCB& callback) {
+    const media::OutputDeviceStatusCB& callback) {
   DVLOG(1) << "WebRtcAudioRenderer::SwitchOutputDevice()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_GE(session_id_, 0);
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(source_);
     DCHECK_NE(state_, UNINITIALIZED);
   }
 
   scoped_refptr<media::AudioRendererSink> new_sink =
       AudioDeviceFactory::NewAudioRendererSink(
           AudioDeviceFactory::kSourceWebRtc, source_render_frame_id_,
           session_id_, device_id, security_origin);
-  if (new_sink->GetOutputDevice()->GetDeviceStatus() !=
-      media::OUTPUT_DEVICE_STATUS_OK) {
-    callback.Run(new_sink->GetOutputDevice()->GetDeviceStatus());
+  media::OutputDeviceStatus status =
+      new_sink->GetOutputDeviceInfo().device_status();
+  if (status != media::OUTPUT_DEVICE_STATUS_OK) {
+    callback.Run(status);
     return;
   }
 
   // Make sure to stop the sink while _not_ holding the lock since the Render()
   // callback may currently be executing and trying to grab the lock while we're
   // stopping the thread on which it runs.
   sink_->Stop();
   audio_renderer_thread_checker_.DetachFromThread();
   sink_ = new_sink;
   output_device_id_ = device_id;
   security_origin_ = security_origin;
   {
     base::AutoLock auto_lock(lock_);
     source_->AudioRendererThreadStopped();
   }
   PrepareSink();
   sink_->Start();
 
   callback.Run(media::OUTPUT_DEVICE_STATUS_OK);
 }
 
-media::AudioParameters WebRtcAudioRenderer::GetOutputParameters() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!sink_.get())
-    return media::AudioParameters();
-
-  return sink_->GetOutputDevice()->GetOutputParameters();
-}
-
-media::OutputDeviceStatus WebRtcAudioRenderer::GetDeviceStatus() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!sink_.get())
-    return media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL;
-
-  return sink_->GetOutputDevice()->GetDeviceStatus();
-}
-
 int WebRtcAudioRenderer::Render(media::AudioBus* audio_bus,
                                 uint32_t frames_delayed,
                                 uint32_t frames_skipped) {
   DCHECK(audio_renderer_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   if (!source_)
     return 0;
 
   // TODO(grunell): Converting from frames to milliseconds will potentially lose
   // hundreds of microseconds which may cause audio video drift. Update
@@ skipping 180 matching lines @@
   }
 }
 
 void WebRtcAudioRenderer::PrepareSink() {
   DCHECK(thread_checker_.CalledOnValidThread());
   media::AudioParameters new_sink_params;
   {
     base::AutoLock lock(lock_);
     new_sink_params = sink_params_;
   }
+
+  const media::OutputDeviceInfo& device_info = sink_->GetOutputDeviceInfo();
+  DCHECK_EQ(device_info.device_status(), media::OUTPUT_DEVICE_STATUS_OK);
+
   // WebRTC does not yet support higher rates than 96000 on the client side
   // and 48000 is the preferred sample rate. Therefore, if 192000 is detected,
   // we change the rate to 48000 instead. The consequence is that the native
   // layer will be opened up at 192kHz but WebRTC will provide data at 48kHz
   // which will then be resampled by the audio converted on the browser side
   // to match the native audio layer.
-  int sample_rate =
-      sink_->GetOutputDevice()->GetOutputParameters().sample_rate();
+  int sample_rate = device_info.output_params().sample_rate();
   DVLOG(1) << "Audio output hardware sample rate: " << sample_rate;
   if (sample_rate >= 192000) {
     DVLOG(1) << "Resampling from 48000 to " << sample_rate << " is required";
     sample_rate = 48000;
   }
   media::AudioSampleRate asr;
   if (media::ToAudioSampleRate(sample_rate, &asr)) {
     UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputSampleRate", asr,
                               media::kAudioSampleRateMax + 1);
   } else {
     UMA_HISTOGRAM_COUNTS("WebRTC.AudioOutputSampleRateUnexpected", sample_rate);
   }
 
   // Calculate the frames per buffer for the source, i.e. the WebRTC client. We
   // use 10 ms of data since the WebRTC client only supports multiples of 10 ms
   // as buffer size where 10 ms is preferred for lowest possible delay.
   const int source_frames_per_buffer = (sample_rate / 100);
   DVLOG(1) << "Using WebRTC output buffer size: " << source_frames_per_buffer;
 
   // Setup sink parameters.
   const int sink_frames_per_buffer = GetOptimalBufferSize(
-      sample_rate,
-      sink_->GetOutputDevice()->GetOutputParameters().frames_per_buffer());
+      sample_rate, device_info.output_params().frames_per_buffer());
   new_sink_params.set_sample_rate(sample_rate);
   new_sink_params.set_frames_per_buffer(sink_frames_per_buffer);
 
   // Create a FIFO if re-buffering is required to match the source input with
   // the sink request. The source acts as provider here and the sink as
   // consumer.
   const bool different_source_sink_frames =
       source_frames_per_buffer != new_sink_params.frames_per_buffer();
   if (different_source_sink_frames) {
     DVLOG(1) << "Rebuffering from " << source_frames_per_buffer << " to "
              << new_sink_params.frames_per_buffer();
   }
   {
     base::AutoLock lock(lock_);
     if ((!audio_fifo_ && different_source_sink_frames) ||
         (audio_fifo_ &&
          audio_fifo_->SizeInFrames() != source_frames_per_buffer)) {
       audio_fifo_.reset(new media::AudioPullFifo(
           kChannels, source_frames_per_buffer,
           base::Bind(&WebRtcAudioRenderer::SourceCallback,
                      base::Unretained(this))));
     }
     sink_params_ = new_sink_params;
   }
 
   sink_->Initialize(new_sink_params, this);
 }
 
 }  // namespace content