Split out audio debug recording from RenderProcessHostImpl.

content/renderer/media/media_stream_audio_processor.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/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 228 matching lines @@
     WebRtcPlayoutDataSource* playout_data_source)
     : render_delay_ms_(0),
       playout_data_source_(playout_data_source),
       audio_mirroring_(false),
       typing_detected_(false),
       stopped_(false) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
   InitializeAudioProcessingModule(constraints, input_params);
 
-  aec_dump_message_filter_ = AecDumpMessageFilter::Get();
-  // In unit tests not creating a message filter, |aec_dump_message_filter_|
+  audio_debug_recorder_ = AudioDebugRecorder::Get();
+  // In unit tests not creating a message filter, |audio_debug_recorder_|
   // will be NULL. We can just ignore that. Other unit tests and browser tests
   // ensure that we do get the filter when we should.
-  if (aec_dump_message_filter_.get())
-    aec_dump_message_filter_->AddDelegate(this);
+  if (audio_debug_recorder_.get())
+    audio_debug_recorder_->AddDelegate(this);
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   Stop();
 }
 
 void MediaStreamAudioProcessor::OnCaptureFormatChanged(
     const media::AudioParameters& input_format) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 54 matching lines @@
   return true;
 }
 
 void MediaStreamAudioProcessor::Stop() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (stopped_)
     return;
 
   stopped_ = true;
 
-  if (aec_dump_message_filter_.get()) {
-    aec_dump_message_filter_->RemoveDelegate(this);
-    aec_dump_message_filter_ = NULL;
+  if (audio_debug_recorder_.get()) {
+    audio_debug_recorder_->RemoveDelegate(this);
+    audio_debug_recorder_ = NULL;
   }
 
   if (!audio_processing_.get())
     return;
 
   audio_processing_.get()->UpdateHistogramsOnCallEnd();
   StopEchoCancellationDump(audio_processing_.get());
 
   if (playout_data_source_) {
     playout_data_source_->RemovePlayoutSink(this);
     playout_data_source_ = NULL;
   }
 }
 
 const media::AudioParameters& MediaStreamAudioProcessor::InputFormat() const {
   return input_format_;
 }
 
 const media::AudioParameters& MediaStreamAudioProcessor::OutputFormat() const {
   return output_format_;
 }
 
-void MediaStreamAudioProcessor::OnAecDumpFile(
-    const IPC::PlatformFileForTransit& file_handle) {
+void MediaStreamAudioProcessor::OnAecDumpFile(base::PlatformFile file_handle) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  base::File file = IPC::PlatformFileForTransitToFile(file_handle);
+  base::File file(file_handle);
   DCHECK(file.IsValid());
 
   if (audio_processing_)
     StartEchoCancellationDump(audio_processing_.get(), file.Pass());
   else
     file.Close();
 }
 
 void MediaStreamAudioProcessor::OnDisableAecDump() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (audio_processing_)
     StopEchoCancellationDump(audio_processing_.get());
 }
 
 void MediaStreamAudioProcessor::OnIpcClosing() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  aec_dump_message_filter_ = NULL;
+  audio_debug_recorder_ = NULL;
 }
 
 void MediaStreamAudioProcessor::OnPlayoutData(media::AudioBus* audio_bus,
                                               int sample_rate,
                                               int audio_delay_milliseconds) {
   DCHECK(render_thread_checker_.CalledOnValidThread());
   DCHECK(audio_processing_->echo_control_mobile()->is_enabled() ^
          audio_processing_->echo_cancellation()->is_enabled());
 
   TRACE_EVENT0("audio", "MediaStreamAudioProcessor::OnPlayoutData");
@@ skipping 293 matching lines @@
   if (echo_information_) {
     echo_information_.get()->UpdateAecDelayStats(ap->echo_cancellation());
   }
 
   // Return 0 if the volume hasn't been changed, and otherwise the new volume.
   return (agc->stream_analog_level() == volume) ?
       0 : agc->stream_analog_level();
 }
 
 }  // namespace content