move the APM to chrome.

content/renderer/media/webrtc_audio_device_impl.cc

 // Copyright 2013 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/strings/string_util.h"
 #include "base/win/windows_version.h"
@@ skipping 33 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::Release() {
   DCHECK(thread_checker_.CalledOnValidThread());
   int ret = base::subtle::Barrier_AtomicIncrement(&ref_count_, -1);
   if (ret == 0) {
     delete this;
   }
   return ret;
 }
+
 int WebRtcAudioDeviceImpl::CaptureData(const std::vector<int>& channels,
                                        const int16* audio_data,
                                        int sample_rate,
                                        int number_of_channels,
                                        int number_of_frames,
                                        int audio_delay_milliseconds,
                                        int current_volume,
                                        bool need_audio_processing,
                                        bool key_pressed) {
   int total_delay_ms = 0;
   {
     base::AutoLock auto_lock(lock_);
     // Return immediately when not recording or |channels| is empty.
     // See crbug.com/274017: renderer crash dereferencing invalid channels[0].
     if (!recording_ || channels.empty())
       return 0;
 
     // Store the reported audio delay locally.
     input_delay_ms_ = audio_delay_milliseconds;
     total_delay_ms = input_delay_ms_ + output_delay_ms_;
     DVLOG(2) << "total delay: " << input_delay_ms_ + output_delay_ms_;
   }
 
-  // Write audio samples in blocks of 10 milliseconds to the registered
-  // webrtc::AudioTransport sink. Keep writing until our internal byte
-  // buffer is empty.
-  const int16* audio_buffer = audio_data;
-  const int samples_per_10_msec = (sample_rate / 100);
-  int accumulated_audio_samples = 0;
-  uint32_t new_volume = 0;
-  while (accumulated_audio_samples < number_of_frames) {
-    // Deliver 10ms of recorded 16-bit linear PCM audio.
-    int new_mic_level = audio_transport_callback_->OnDataAvailable(
-        &channels[0],
-        channels.size(),
-        audio_buffer,
-        sample_rate,
-        number_of_channels,
-        samples_per_10_msec,
-        total_delay_ms,
-        current_volume,
-        key_pressed,
-        need_audio_processing);
-
-    accumulated_audio_samples += samples_per_10_msec;
-    audio_buffer += samples_per_10_msec * number_of_channels;
-
-    // The latest non-zero new microphone level will be returned.
-    if (new_mic_level)
-      new_volume = new_mic_level;
-  }
-
-  return new_volume;
+  // Deliver 10ms of recorded 16-bit linear PCM audio.
+  return audio_transport_callback_->OnDataAvailable(
+      &channels[0], channels.size(), audio_data, sample_rate,
+      number_of_channels, number_of_frames, total_delay_ms,
+      current_volume, key_pressed, need_audio_processing);
 }
 
 void WebRtcAudioDeviceImpl::SetCaptureFormat(
     const media::AudioParameters& params) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::SetCaptureFormat()";
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebRtcAudioDeviceImpl::RenderData(uint8* audio_data,
                                        int number_of_channels,
@@ skipping 26 matching lines @@
     // Get 10ms and append output to temporary byte buffer.
     audio_transport_callback_->NeedMorePlayData(samples_per_10_msec,
                                                 bytes_per_sample,
                                                 channels,
                                                 samples_per_sec,
                                                 audio_data,
                                                 num_audio_samples);
     accumulated_audio_samples += num_audio_samples;
     audio_data += bytes_per_10_msec;
   }
+
+  base::AutoLock auto_lock(lock_);
+  for (RenderDataObservers::const_iterator iter =
+           render_data_observers_.begin();
+      iter != render_data_observers_.end(); ++iter) {
+    (*iter)->OnRenderData(
+        reinterpret_cast<const int16*>(audio_data),
+        samples_per_sec,
+        number_of_channels,
+        number_of_frames,
+        audio_delay_milliseconds);
+  }
 }
 
 void WebRtcAudioDeviceImpl::SetRenderFormat(const AudioParameters& params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   output_audio_parameters_ = params;
 }
 
 void WebRtcAudioDeviceImpl::RemoveAudioRenderer(WebRtcAudioRenderer* renderer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(renderer, renderer_);
@@ skipping 32 matching lines @@
     return 0;
 
   StopRecording();
   StopPlayout();
 
   DCHECK(!renderer_.get() || !renderer_->IsStarted())
       << "The shared audio renderer shouldn't be running";
 
   capturers_.clear();
 
+  // Notify all the remaining observers that the render object is going away.
+  for (RenderDataObservers::const_iterator iter =
+           render_data_observers_.begin();
+      iter != render_data_observers_.end(); ++iter) {
+    (*iter)->OnRenderClosing();
+  }
+  render_data_observers_.clear();
+
   initialized_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Initialized() const {
   return initialized_;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutIsAvailable(bool* available) {
   *available = initialized_;
@@ skipping 259 matching lines @@
   base::AutoLock auto_lock(lock_);
   for (CapturerList::const_iterator iter = capturers_.begin();
        iter != capturers_.end(); ++iter) {
     if (!(*iter)->device_id().empty())
       return *iter;
   }
 
   return NULL;
 }
 
+void WebRtcAudioDeviceImpl::AddRenderDataObserver(
+    WebRtcAudioRenderDataObserver* observer) {
+  DCHECK(observer);
+  base::AutoLock auto_lock(lock_);
+  DCHECK(std::find(render_data_observers_.begin(),
+                   render_data_observers_.end(),
+                   observer) == render_data_observers_.end());
+  render_data_observers_.push_back(observer);
+}
+
+void WebRtcAudioDeviceImpl::RemoveRenderDataObserver(
+    WebRtcAudioRenderDataObserver* observer) {
+  DCHECK(observer);
+  base::AutoLock auto_lock(lock_);
+  RenderDataObservers::iterator iter = std::find(
+      render_data_observers_.begin(), render_data_observers_.end(), observer);
+  // TODO(xians): why not DCHECK.
+  if (iter == render_data_observers_.end())
+    return;
+
+  render_data_observers_.erase(iter);
+}
+
 }  // namespace content