Support the Aec dump for the APM in 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/platform_file.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
 
 using media::AudioParameters;
 using media::ChannelLayout;
 
 namespace content {
 
 WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()
     : ref_count_(0),
       audio_transport_callback_(NULL),
       input_delay_ms_(0),
       output_delay_ms_(0),
       initialized_(false),
       playing_(false),
       recording_(false),
-      microphone_volume_(0) {
+      microphone_volume_(0),
+      aec_dump_file_(base::kInvalidPlatformFileValue) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
 }
 
 WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl()";
   DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
 }
 
 int32_t WebRtcAudioDeviceImpl::AddRef() {
@@ skipping 172 matching lines @@
   // Calling Terminate() multiple times in a row is OK.
   if (!initialized_)
     return 0;
 
   StopRecording();
   StopPlayout();
 
   DCHECK(!renderer_.get() || !renderer_->IsStarted())
       << "The shared audio renderer shouldn't be running";
 
+  DisableAecDump();
+
   capturers_.clear();
 
   initialized_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Initialized() const {
   return initialized_;
 }
 
@@ skipping 191 matching lines @@
   renderer_ = renderer;
   return true;
 }
 
 void WebRtcAudioDeviceImpl::AddAudioCapturer(
     const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(capturer.get());
   DCHECK(!capturer->device_id().empty());
-  base::AutoLock auto_lock(lock_);
-  DCHECK(std::find(capturers_.begin(), capturers_.end(), capturer) ==
-      capturers_.end());
-  capturers_.push_back(capturer);
+  {
+    base::AutoLock auto_lock(lock_);
+    DCHECK(std::find(capturers_.begin(), capturers_.end(), capturer) ==
+        capturers_.end());
+    capturers_.push_back(capturer);
+  }
+
+  // Start the Aec dump if the Aec dump has been enabled and has not been
+  // started.
+  if (aec_dump_file_ != base::kInvalidPlatformFileValue)
+    MaybeStartAecDump();
 }
 
 void WebRtcAudioDeviceImpl::RemoveAudioCapturer(
     const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(capturer.get());
   base::AutoLock auto_lock(lock_);
   capturers_.remove(capturer);
 }
@@ skipping 36 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   // If there is no capturer or there are more than one open capture devices,
   // return false.
   if (capturers_.empty() || capturers_.size() > 1)
     return false;
 
   return GetDefaultCapturer()->GetPairedOutputParameters(
       session_id, output_sample_rate, output_frames_per_buffer);
 }
 
+void WebRtcAudioDeviceImpl::EnableAecDump(
+    const base::PlatformFile& aec_dump_file) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(aec_dump_file, base::kInvalidPlatformFileValue);
+  DCHECK_EQ(aec_dump_file_, base::kInvalidPlatformFileValue);
+  aec_dump_file_ = aec_dump_file;
+  MaybeStartAecDump();
+}
+
+void WebRtcAudioDeviceImpl::DisableAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Simply invalidate the |aec_dump_file_| if we have not pass the ownership
+  // to WebRtc.
+  if (aec_dump_file_ != base::kInvalidPlatformFileValue) {
+    base::ClosePlatformFile(aec_dump_file_);
+    aec_dump_file_ = base::kInvalidPlatformFileValue;
+    return;
+  }
+
+  // We might have call StartAecDump() on one of the capturer. Loop
+  // through all the capturers and call StopAecDump() on each of them.
+  for (CapturerList::const_iterator iter = capturers_.begin();
+       iter != capturers_.end(); ++iter) {
+    (*iter)->StopAecDump();
+  }
+}
+
+void WebRtcAudioDeviceImpl::MaybeStartAecDump() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(aec_dump_file_, base::kInvalidPlatformFileValue);
+
+  // Start the Aec dump on the current default capturer.
+  scoped_refptr<WebRtcAudioCapturer> default_capturer(GetDefaultCapturer());
+  if (!default_capturer)
+    return;
+
+  default_capturer->StartAecDump(aec_dump_file_);
+
+  // Invalidate the |aec_dump_file_| since the ownership of the file has been
+  // passed to WebRtc.
+  aec_dump_file_ = base::kInvalidPlatformFileValue;
+}
+
 }  // namespace content