Switching audio clients to using RestartableAudioRendererSink interface as a sink.

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/restartable_audio_output_device_factory.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_output_device.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/libjingle/source/talk/app/webrtc/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
@@ skipping 182 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(source);
   DCHECK(!sink_.get());
   DCHECK_GE(session_id_, 0);
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, UNINITIALIZED);
     DCHECK(!source_);
   }
 
-  sink_ =
-      AudioDeviceFactory::NewOutputDevice(source_render_frame_id_, session_id_,
-                                          output_device_id_, security_origin_);
-  if (sink_->GetDeviceStatus() != media::OUTPUT_DEVICE_STATUS_OK)
+  sink_ = RestartableAudioOutputDeviceFactory::NewOutputDevice(
+      RestartableAudioOutputDeviceFactory::kSourceWebRTC,
+      source_render_frame_id_, session_id_, output_device_id_,
+      security_origin_);
+
+  if (sink_->GetOutputDevice()->GetDeviceStatus() !=
+      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;
 
     // User must call Play() before any audio can be heard.
     state_ = PAUSED;
   }
   sink_->Start();
+  sink_->Play();  // RestartableAudioOutputDevice does not play on start.
 
   return true;
 }
 
 scoped_refptr<MediaStreamAudioRenderer>
 WebRtcAudioRenderer::CreateSharedAudioRendererProxy(
     const blink::WebMediaStream& media_stream) {
   content::SharedAudioRenderer::OnPlayStateChanged on_play_state_changed =
       base::Bind(&WebRtcAudioRenderer::OnPlayStateChanged, this);
   return new SharedAudioRenderer(this, media_stream, on_play_state_changed);
@@ skipping 122 matching lines @@
     const media::SwitchOutputDeviceCB& 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::AudioOutputDevice> new_sink =
-      AudioDeviceFactory::NewOutputDevice(source_render_frame_id_, session_id_,
-                                          device_id, security_origin);
-  if (new_sink->GetDeviceStatus() != media::OUTPUT_DEVICE_STATUS_OK) {
-    callback.Run(new_sink->GetDeviceStatus());
+  scoped_refptr<media::RestartableAudioRendererSink> new_sink =
+      RestartableAudioOutputDeviceFactory::NewOutputDevice(
+          RestartableAudioOutputDeviceFactory::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());
     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_->GetOutputParameters();
+  return sink_->GetOutputDevice()->GetOutputParameters();
 }
 
 media::OutputDeviceStatus WebRtcAudioRenderer::GetDeviceStatus() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!sink_.get())
     return media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL;
 
-  return sink_->GetDeviceStatus();
+  return sink_->GetOutputDevice()->GetDeviceStatus();
 }
 
 int WebRtcAudioRenderer::Render(media::AudioBus* audio_bus,
                                 uint32_t audio_delay_milliseconds,
                                 uint32_t frames_skipped) {
   DCHECK(audio_renderer_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   if (!source_)
     return 0;
 
@@ skipping 178 matching lines @@
   {
     base::AutoLock lock(lock_);
     new_sink_params = sink_params_;
   }
   // 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_->GetOutputParameters().sample_rate();
+  int sample_rate =
+      sink_->GetOutputDevice()->GetOutputParameters().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_->GetOutputParameters().frames_per_buffer());
+      sample_rate,
+      sink_->GetOutputDevice()->GetOutputParameters().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