Change existing aec dump tests to use webrtc::AecDump.

webrtc/modules/audio_processing/test/debug_dump_test.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <stddef.h>  // size_t
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "webrtc/base/task_queue.h"
 #include "webrtc/modules/audio_coding/neteq/tools/resample_input_audio_file.h"
+#include "webrtc/modules/audio_processing/aec_dump/aec_dump_factory.h"
 #include "webrtc/modules/audio_processing/test/debug_dump_replayer.h"
 #include "webrtc/modules/audio_processing/test/test_utils.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 
 namespace webrtc {
 namespace test {
 
 namespace {
@@ skipping 69 matching lines @@
   // Reverse file format.
   const std::string reverse_file_name_;
   ResampleInputAudioFile reverse_audio_;
   const int reverse_file_channels_;
 
   // Buffer for APM input/output.
   std::unique_ptr<ChannelBuffer<float>> input_;
   std::unique_ptr<ChannelBuffer<float>> reverse_;
   std::unique_ptr<ChannelBuffer<float>> output_;
 
+  rtc::TaskQueue worker_queue_;
   std::unique_ptr<AudioProcessing> apm_;
 
   const std::string dump_file_name_;
 };
 
 DebugDumpGenerator::DebugDumpGenerator(const std::string& input_file_name,
                                        int input_rate_hz,
                                        int input_channels,
                                        const std::string& reverse_file_name,
                                        int reverse_rate_hz,
                                        int reverse_channels,
                                        const Config& config,
                                        const std::string& dump_file_name)
     : input_config_(input_rate_hz, input_channels),
       reverse_config_(reverse_rate_hz, reverse_channels),
       output_config_(input_rate_hz, input_channels),
       input_audio_(input_file_name, input_rate_hz, input_rate_hz),
       input_file_channels_(input_channels),
       reverse_audio_(reverse_file_name, reverse_rate_hz, reverse_rate_hz),
       reverse_file_channels_(reverse_channels),
       input_(new ChannelBuffer<float>(input_config_.num_frames(),
                                       input_config_.num_channels())),
       reverse_(new ChannelBuffer<float>(reverse_config_.num_frames(),
                                         reverse_config_.num_channels())),
       output_(new ChannelBuffer<float>(output_config_.num_frames(),
                                        output_config_.num_channels())),
+      worker_queue_("debug_dump_generator_worker_queue"),
       apm_(AudioProcessing::Create(config)),
-      dump_file_name_(dump_file_name) {
-}
+      dump_file_name_(dump_file_name) {}
 
 DebugDumpGenerator::DebugDumpGenerator(
     const Config& config,
     const AudioProcessing::Config& apm_config)
     : DebugDumpGenerator(ResourcePath("near32_stereo", "pcm"),
                          32000,
                          2,
                          ResourcePath("far32_stereo", "pcm"),
                          32000,
                          2,
@@ skipping 34 matching lines @@
   output_config_.set_sample_rate_hz(rate_hz);
   MaybeResetBuffer(&output_, output_config_);
 }
 
 void DebugDumpGenerator::SetOutputChannels(int channels) {
   output_config_.set_num_channels(channels);
   MaybeResetBuffer(&output_, output_config_);
 }
 
 void DebugDumpGenerator::StartRecording() {
-  apm_->StartDebugRecording(dump_file_name_.c_str(), -1);
+  apm_->AttachAecDump(
+      AecDumpFactory::Create(dump_file_name_.c_str(), -1, &worker_queue_));
 }
 
 void DebugDumpGenerator::Process(size_t num_blocks) {
   for (size_t i = 0; i < num_blocks; ++i) {
     ReadAndDeinterleave(&reverse_audio_, reverse_file_channels_,
                         reverse_config_, reverse_->channels());
     ReadAndDeinterleave(&input_audio_, input_file_channels_, input_config_,
                         input_->channels());
     RTC_CHECK_EQ(AudioProcessing::kNoError, apm_->set_stream_delay_ms(100));
     apm_->set_stream_key_pressed(i % 10 == 9);
     RTC_CHECK_EQ(AudioProcessing::kNoError,
                  apm_->ProcessStream(input_->channels(), input_config_,
                                      output_config_, output_->channels()));
 
     RTC_CHECK_EQ(AudioProcessing::kNoError,
                  apm_->ProcessReverseStream(reverse_->channels(),
                                             reverse_config_,
                                             reverse_config_,
                                             reverse_->channels()));
   }
 }
 
 void DebugDumpGenerator::StopRecording() {
-  apm_->StopDebugRecording();
+  apm_->DetachAecDump();
 }
 
 void DebugDumpGenerator::ReadAndDeinterleave(ResampleInputAudioFile* audio,
                                              int channels,
                                              const StreamConfig& config,
                                              float* const* buffer) {
   const size_t num_frames = config.num_frames();
   const int out_channels = config.num_channels();
 
   std::vector<int16_t> signal(channels * num_frames);
@@ skipping 363 matching lines @@
   config.Set<ExperimentalNs>(new ExperimentalNs(true));
   DebugDumpGenerator generator(config, AudioProcessing::Config());
   generator.StartRecording();
   generator.Process(100);
   generator.StopRecording();
   VerifyDebugDump(generator.dump_file_name());
 }
 
 }  // namespace test
 }  // namespace webrtc