Adds AudioDevice factory for all audio clients in Chrome

content/renderer/media/webrtc_audio_device_impl.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_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
+#include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
 
 using media::AudioParameters;
 
 static const int64 kMillisecondsBetweenProcessCalls = 5000;
 static const double kMaxVolumeLevel = 255.0;
@@ skipping 98 matching lines @@
     // Report unexpected sample rates using a unique histogram name.
     if (dir == kAudioOutput) {
       UMA_HISTOGRAM_COUNTS("WebRTC.AudioOutputFramesPerBufferUnexpected",
                            param);
     } else {
       UMA_HISTOGRAM_COUNTS("WebRTC.AudioInputFramesPerBufferUnexpected", param);
     }
   }
 }
 
-WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()
+WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl(
+    AudioDeviceFactoryInterface* audio_device_factory)
     : ref_count_(0),
       render_loop_(base::MessageLoopProxy::current()),
       audio_transport_callback_(NULL),
       input_delay_ms_(0),
       output_delay_ms_(0),
       last_error_(AudioDeviceModule::kAdmErrNone),
       last_process_time_(base::TimeTicks::Now()),
       session_id_(0),
       bytes_per_sample_(0),
       initialized_(false),
       playing_(false),
       recording_(false),
       agc_is_enabled_(false) {
     DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
+    DCHECK(audio_device_factory);
+    // TODO(henrika): remove this restriction when factory is used for the
+    // input side as well.
     DCHECK(RenderThreadImpl::current()) <<
         "WebRtcAudioDeviceImpl must be constructed on the render thread";
+    audio_output_device_ = audio_device_factory->Create();
+    DCHECK(audio_output_device_);
 }
 
 WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl()";
   if (playing_)
     StopPlayout();
   if (recording_)
     StopRecording();
   if (initialized_)
     Terminate();
@@ skipping 247 matching lines @@
                    this, &error, &event));
     event.Wait();
     return error;
   }
 
   // Calling Init() multiple times in a row is OK.
   if (initialized_)
     return 0;
 
   DCHECK(!audio_input_device_);
-  DCHECK(!audio_output_device_);
   DCHECK(!input_buffer_.get());
   DCHECK(!output_buffer_.get());
 
   // TODO(henrika): it could be possible to allow one of the directions (input
   // or output) to use a non-supported rate. As an example: if only the
   // output rate is OK, we could finalize Init() and only set up an AudioDevice.
 
   // Ask the browser for the default audio output hardware sample-rate.
   // This request is based on a synchronous IPC message.
   int out_sample_rate = audio_hardware::GetOutputSampleRate();
@@ skipping 152 matching lines @@
   audio_input_device_ = new AudioInputDevice(
       input_audio_parameters_, this, this);
 
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputChannelLayout",
                             out_channel_layout, CHANNEL_LAYOUT_MAX);
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
                             in_channel_layout, CHANNEL_LAYOUT_MAX);
   AddHistogramFramesPerBuffer(kAudioOutput, out_buffer_size);
   AddHistogramFramesPerBuffer(kAudioInput, in_buffer_size);
 
-  // Create and configure the audio rendering client.
-  audio_output_device_ = new AudioDevice(output_audio_parameters_, this);
+  // Configure the audio rendering client.
+  audio_output_device_->Initialize(output_audio_parameters_, this);
 
   DCHECK(audio_input_device_);
-  DCHECK(audio_output_device_);
 
   // Allocate local audio buffers based on the parameters above.
   // It is assumed that each audio sample contains 16 bits and each
   // audio frame contains one or two audio samples depending on the
   // number of channels.
   input_buffer_.reset(new int16[input_buffer_size() * input_channels()]);
   output_buffer_.reset(new int16[output_buffer_size() * output_channels()]);
 
   DCHECK(input_buffer_.get());
   DCHECK(output_buffer_.get());
@@ skipping 19 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::Terminate() {
   DVLOG(1) << "Terminate()";
 
   // Calling Terminate() multiple times in a row is OK.
   if (!initialized_)
     return 0;
 
   DCHECK(audio_input_device_);
-  DCHECK(audio_output_device_);
   DCHECK(input_buffer_.get());
   DCHECK(output_buffer_.get());
 
   // Release all resources allocated in Init().
   audio_input_device_ = NULL;
-  audio_output_device_ = NULL;
   input_buffer_.reset();
   output_buffer_.reset();
 
   initialized_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Initialized() const {
   return initialized_;
 }
@@ skipping 43 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::SetRecordingDevice(WindowsDeviceType device) {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::SetRecordingDevice() "
            << "NOT IMPLEMENTED";
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutIsAvailable(bool* available) {
   DVLOG(1) << "PlayoutIsAvailable()";
-  *available = (audio_output_device_ != NULL);
+  *available = initialized();
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::InitPlayout() {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::InitPlayout() "
            << "NOT IMPLEMENTED";
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::PlayoutIsInitialized() const {
   DVLOG(1) << "PlayoutIsInitialized()";
-  return (audio_output_device_ != NULL);
+  return initialized();
 }
 
 int32_t WebRtcAudioDeviceImpl::RecordingIsAvailable(bool* available) {
   DVLOG(1) << "RecordingIsAvailable()";
   *available = (audio_input_device_ != NULL);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::InitRecording() {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::InitRecording() "
@@ skipping 440 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }