Switching audio clients to using RestartableAudioRendererSink interface as a sink.

content/renderer/media/webrtc_local_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_local_audio_renderer.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
-#include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
+#include "content/renderer/media/restartable_audio_output_device_factory.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/render_frame_impl.h"
-#include "media/audio/audio_output_device.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_shifter.h"
 
 namespace content {
 
 namespace {
 
 enum LocalRendererSinkStates {
   kSinkStarted = 0,
   kSinkNeverStarted,
@@ skipping 88 matching lines @@
 }
 
 void WebRtcLocalAudioRenderer::Start() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Start()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // We get audio data from |audio_track_|...
   MediaStreamAudioSink::AddToAudioTrack(this, audio_track_);
   // ...and |sink_| will get audio data from us.
   DCHECK(!sink_.get());
-  sink_ =
-      AudioDeviceFactory::NewOutputDevice(source_render_frame_id_, session_id_,
-                                          output_device_id_, security_origin_);
+  sink_ = RestartableAudioOutputDeviceFactory::NewOutputDevice(
+      RestartableAudioOutputDeviceFactory::kSourceLocalUserMedia,
+      source_render_frame_id_, session_id_, output_device_id_,
+      security_origin_);
 
   base::AutoLock auto_lock(thread_lock_);
   last_render_time_ = base::TimeTicks::Now();
   playing_ = false;
 }
 
 void WebRtcLocalAudioRenderer::Stop() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Stop()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 89 matching lines @@
   return true;
 }
 
 void WebRtcLocalAudioRenderer::SwitchOutputDevice(
     const std::string& device_id,
     const url::Origin& security_origin,
     const media::SwitchOutputDeviceCB& callback) {
   DVLOG(1) << "WebRtcLocalAudioRenderer::SwitchOutputDevice()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  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::kSourceLocalUserMedia,
+          source_render_frame_id_, session_id_, device_id, security_origin);
+  media::OutputDeviceStatus new_sink_status =
+      new_sink->GetOutputDevice()->GetDeviceStatus();
+  if (new_sink_status != media::OUTPUT_DEVICE_STATUS_OK) {
+    callback.Run(new_sink_status);
     return;
   }
 
   output_device_id_ = device_id;
   security_origin_ = security_origin;
   bool was_sink_started = sink_started_;
 
   if (sink_.get())
     sink_->Stop();
 
   sink_started_ = false;
   sink_ = new_sink;
-  int frames_per_buffer = sink_->GetOutputParameters().frames_per_buffer();
+  int frames_per_buffer =
+      sink_->GetOutputDevice()->GetOutputParameters().frames_per_buffer();
   sink_params_ = source_params_;
   sink_params_.set_frames_per_buffer(WebRtcAudioRenderer::GetOptimalBufferSize(
       source_params_.sample_rate(), frames_per_buffer));
 
   if (was_sink_started)
     MaybeStartSink();
 
   callback.Run(media::OUTPUT_DEVICE_STATUS_OK);
 }
 
 media::AudioParameters WebRtcLocalAudioRenderer::GetOutputParameters() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (!sink_.get())
     return media::AudioParameters();
 
-  return sink_->GetOutputParameters();
+  return sink_->GetOutputDevice()->GetOutputParameters();
 }
 
 media::OutputDeviceStatus WebRtcLocalAudioRenderer::GetDeviceStatus() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (!sink_.get())
     return media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL;
 
-  return sink_->GetDeviceStatus();
+  return sink_->GetOutputDevice()->GetDeviceStatus();
 }
 
 void WebRtcLocalAudioRenderer::MaybeStartSink() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "WebRtcLocalAudioRenderer::MaybeStartSink()";
 
   if (!sink_.get() || !source_params_.IsValid())
     return;
 
   {
     // Clear up the old data in the FIFO.
     base::AutoLock auto_lock(thread_lock_);
     audio_shifter_->Flush();
   }
 
   if (!sink_params_.IsValid() || !playing_ || !volume_ || sink_started_ ||
-      sink_->GetDeviceStatus() != media::OUTPUT_DEVICE_STATUS_OK)
+      sink_->GetOutputDevice()->GetDeviceStatus() !=
+          media::OUTPUT_DEVICE_STATUS_OK)
     return;
 
   DVLOG(1) << "WebRtcLocalAudioRenderer::MaybeStartSink() -- Starting sink_.";
   sink_->Initialize(sink_params_, this);
   sink_->Start();
+  sink_->Play();  // It used to be AudioOutputDevice which plays on start.
   sink_started_ = true;
   UMA_HISTOGRAM_ENUMERATION("Media.LocalRendererSinkStates",
                             kSinkStarted, kSinkStatesMax);
 }
 
 void WebRtcLocalAudioRenderer::ReconfigureSink(
     const media::AudioParameters& params) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "WebRtcLocalAudioRenderer::ReconfigureSink()";
@@ skipping 21 matching lines @@
     audio_shifter_.reset(new_shifter);
   }
 
   if (!sink_.get())
     return;  // WebRtcLocalAudioRenderer has not yet been started.
 
   // Stop |sink_| and re-create a new one to be initialized with different audio
   // parameters.  Then, invoke MaybeStartSink() to restart everything again.
   sink_->Stop();
   sink_started_ = false;
-  sink_ =
-      AudioDeviceFactory::NewOutputDevice(source_render_frame_id_, session_id_,
-                                          output_device_id_, security_origin_);
-  int frames_per_buffer = sink_->GetOutputParameters().frames_per_buffer();
+  sink_ = RestartableAudioOutputDeviceFactory::NewOutputDevice(
+      RestartableAudioOutputDeviceFactory::kSourceLocalUserMedia,
+      source_render_frame_id_, session_id_, output_device_id_,
+      security_origin_);
+  int frames_per_buffer =
+      sink_->GetOutputDevice()->GetOutputParameters().frames_per_buffer();
   sink_params_ = source_params_;
   sink_params_.set_frames_per_buffer(WebRtcAudioRenderer::GetOptimalBufferSize(
       source_params_.sample_rate(), frames_per_buffer));
   MaybeStartSink();
 }
 
 }  // namespace content