media/webrtc/audio_processor_unittest.cc - chromium/src - Git at Google

 // Copyright 2018 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 <stddef.h>
 #include <stdint.h>

 #include <string>
 #include <vector>

 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/webrtc/audio_processor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::Return;

 namespace media {

 namespace {

 const int kAudioProcessingSampleRate = 48000;
 const int kAudioProcessingNumberOfChannels = 1;

 // The number of packers used for testing.
 const int kNumberOfPacketsForTest = 100;
 const int kMaxNumberOfPlayoutDataChannels = 2;

 void ReadDataFromSpeechFile(char* data, int length) {
   base::FilePath file;
   CHECK(base::PathService::Get(base::DIR_SOURCE_ROOT, &file));
   file = file.Append(FILE_PATH_LITERAL("media"))
              .Append(FILE_PATH_LITERAL("test"))
              .Append(FILE_PATH_LITERAL("data"))
              .Append(FILE_PATH_LITERAL("speech_16b_stereo_48kHz.raw"));
   DCHECK(base::PathExists(file));
   int64_t data_file_size64 = 0;
   DCHECK(base::GetFileSize(file, &data_file_size64));
   EXPECT_EQ(length, base::ReadFile(file, data, length));
   DCHECK(data_file_size64 > length);
 }

 }  // namespace

 class WebRtcAudioProcessorTest : public ::testing::Test {
  public:
   WebRtcAudioProcessorTest()
       : params_(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                 media::CHANNEL_LAYOUT_STEREO,
                 48000,
                 480) {}

  protected:
   // Helper method to save duplicated code.
   void ProcessDataAndVerifyFormat(AudioProcessor* audio_processor,
                                   int expected_output_sample_rate,
                                   int expected_output_channels,
                                   int expected_output_buffer_size) {
     // Read the audio data from a file.
     const media::AudioParameters& params = audio_processor->audio_parameters_;
     const int packet_size = params.frames_per_buffer() * 2 * params.channels();
     const size_t length = packet_size * kNumberOfPacketsForTest;
     std::unique_ptr<char[]> capture_data(new char[length]);
     ReadDataFromSpeechFile(capture_data.get(), length);
     const int16_t* data_ptr =
         reinterpret_cast<const int16_t*>(capture_data.get());
     std::unique_ptr<media::AudioBus> data_bus =
         media::AudioBus::Create(params.channels(), params.frames_per_buffer());

     // |data_bus_playout| is used if the number of capture channels is larger
     // than max allowed playout channels. |data_bus_playout_to_use| points to
     // the AudioBus to use, either |data_bus| or |data_bus_playout|.
     std::unique_ptr<media::AudioBus> data_bus_playout;
     media::AudioBus* data_bus_playout_to_use = data_bus.get();
     media::AudioParameters playout_params = params;
     if (params.channels() > kMaxNumberOfPlayoutDataChannels) {
       data_bus_playout =
           media::AudioBus::CreateWrapper(kMaxNumberOfPlayoutDataChannels);
       data_bus_playout->set_frames(params.frames_per_buffer());
       data_bus_playout_to_use = data_bus_playout.get();
       playout_params.Reset(params.format(), CHANNEL_LAYOUT_STEREO,
                            params.sample_rate(), params.frames_per_buffer());
     }

     const base::TimeDelta input_capture_delay =
         base::TimeDelta::FromMilliseconds(20);
     for (int i = 0; i < kNumberOfPacketsForTest; ++i) {
       data_bus->FromInterleaved(data_ptr, data_bus->frames(), 2);
       // |audio_processor| does nothing when the audio processing is off in
       // the processor.
       webrtc::AudioProcessing* ap = audio_processor->audio_processing_.get();
       const bool is_aec_enabled = ap && ap->GetConfig().echo_canceller.enabled;
       if (is_aec_enabled) {
         if (params.channels() > kMaxNumberOfPlayoutDataChannels) {
           for (int i = 0; i < kMaxNumberOfPlayoutDataChannels; ++i) {
             data_bus_playout->SetChannelData(
                 i, const_cast<float*>(data_bus->channel(i)));
           }
         }
         base::TimeTicks in_the_future =
             base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(10);
         audio_processor->AnalyzePlayout(*data_bus_playout_to_use,
                                         playout_params, in_the_future);
       }

       auto result = audio_processor->ProcessCapture(
           *data_bus, base::TimeTicks::Now() - input_capture_delay, 1.0, false);
       data_ptr += params.frames_per_buffer() * params.channels();
     }
   }

   void VerifyEnabledComponents(AudioProcessor* audio_processor) {
     webrtc::AudioProcessing* audio_processing =
         audio_processor->audio_processing_.get();
     webrtc::AudioProcessing::Config ap_config = audio_processing->GetConfig();
     EXPECT_TRUE(ap_config.echo_canceller.enabled);
     EXPECT_FALSE(ap_config.echo_canceller.mobile_mode);
     EXPECT_TRUE(ap_config.high_pass_filter.enabled);

     EXPECT_TRUE(audio_processing->noise_suppression()->is_enabled());
     EXPECT_TRUE(audio_processing->noise_suppression()->level() ==
                 webrtc::NoiseSuppression::kHigh);
     EXPECT_TRUE(audio_processing->gain_control()->is_enabled());
     EXPECT_TRUE(audio_processing->gain_control()->mode() ==
                 webrtc::GainControl::kAdaptiveAnalog);
     EXPECT_TRUE(audio_processing->voice_detection()->is_enabled());
     EXPECT_TRUE(audio_processing->voice_detection()->likelihood() ==
                 webrtc::VoiceDetection::kVeryLowLikelihood);
   }

   AudioProcessingSettings GetEnabledAudioProcessingSettings() const {
     AudioProcessingSettings settings;
     settings.echo_cancellation = EchoCancellationType::kAec2;
     settings.noise_suppression = NoiseSuppressionType::kExperimental;
     settings.automatic_gain_control = AutomaticGainControlType::kExperimental;
     settings.high_pass_filter = true;
     settings.typing_detection = true;
     return settings;
   }

   base::test::ScopedTaskEnvironment scoped_task_environment_;
   media::AudioParameters params_;
 };

 TEST_F(WebRtcAudioProcessorTest, WithAudioProcessing) {
   AudioProcessor audio_processor(params_, GetEnabledAudioProcessingSettings());
   VerifyEnabledComponents(&audio_processor);
   ProcessDataAndVerifyFormat(&audio_processor, kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannels,
                              kAudioProcessingSampleRate / 100);
 }

 TEST_F(WebRtcAudioProcessorTest, WithoutAnyProcessing) {
   // All processing settings are disabled by default
   AudioProcessingSettings settings;
   const media::AudioParameters source_params(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       media::CHANNEL_LAYOUT_STEREO, kAudioProcessingSampleRate,
       kAudioProcessingSampleRate / 100);
   AudioProcessor audio_processor(source_params, settings);

   ProcessDataAndVerifyFormat(&audio_processor, params_.sample_rate(),
                              params_.channels(), params_.sample_rate() / 100);
 }

 TEST_F(WebRtcAudioProcessorTest, TestAllSampleRates) {
   for (int sample_rate : {8000, 16000, 32000, 44100, 48000}) {
     int buffer_size = sample_rate / 100;
     media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                   media::CHANNEL_LAYOUT_STEREO, sample_rate,
                                   buffer_size);
     AudioProcessor audio_processor(params, GetEnabledAudioProcessingSettings());

     VerifyEnabledComponents(&audio_processor);

     ProcessDataAndVerifyFormat(&audio_processor, kAudioProcessingSampleRate,
                                kAudioProcessingNumberOfChannels,
                                kAudioProcessingSampleRate / 100);
   }
 }

 TEST_F(WebRtcAudioProcessorTest, TestStereoAudio) {
   // All processing settings are disabled by default
   AudioProcessingSettings settings;
   settings.stereo_mirroring = true;
   const media::AudioParameters source_params(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       media::CHANNEL_LAYOUT_STEREO, kAudioProcessingSampleRate,
       kAudioProcessingSampleRate / 100);
   AudioProcessor audio_processor(source_params, settings);

   // Construct left and right channels, and assign different values to the
   // first data of the left channel and right channel.
   const int size = media::AudioBus::CalculateMemorySize(source_params);
   std::unique_ptr<float, base::AlignedFreeDeleter> left_channel(
       static_cast<float*>(base::AlignedAlloc(size, 32)));
   std::unique_ptr<float, base::AlignedFreeDeleter> right_channel(
       static_cast<float*>(base::AlignedAlloc(size, 32)));
   std::unique_ptr<media::AudioBus> wrapper =
       media::AudioBus::CreateWrapper(source_params.channels());
   wrapper->set_frames(source_params.frames_per_buffer());
   wrapper->SetChannelData(0, left_channel.get());
   wrapper->SetChannelData(1, right_channel.get());
   wrapper->Zero();
   float* left_channel_ptr = left_channel.get();
   left_channel_ptr[0] = 1.0f;

   // Run the test consecutively to make sure the stereo channels are not
   // flipped back and forth.
   static const int kNumberOfPacketsForTest = 100;
   const base::TimeDelta pushed_capture_delay =
       base::TimeDelta::FromMilliseconds(42);
   for (int i = 0; i < kNumberOfPacketsForTest; ++i) {
     auto result = audio_processor.ProcessCapture(
         *wrapper, base::TimeTicks::Now() + pushed_capture_delay, 1.0, false);

     EXPECT_EQ(result.audio.channel(0)[0], 0);
     EXPECT_NE(result.audio.channel(1)[0], 0);
   }
 }

 TEST_F(WebRtcAudioProcessorTest, TestWithKeyboardMicChannel) {
   AudioProcessingSettings settings = GetEnabledAudioProcessingSettings();
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
                                 kAudioProcessingSampleRate,
                                 kAudioProcessingSampleRate / 100);
   AudioProcessor audio_processor(params, settings);
   ProcessDataAndVerifyFormat(&audio_processor, kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannels,
                              kAudioProcessingSampleRate / 100);
 }

 TEST_F(WebRtcAudioProcessorTest, StartStopAecDump) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_directory.GetPath(),
                                              &temp_file_path));
   {
     AudioProcessor audio_processor(params_,
                                    GetEnabledAudioProcessingSettings());

     // Start and stop recording.
     audio_processor.StartEchoCancellationDump(base::File(
         temp_file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN));
     audio_processor.StopEchoCancellationDump();

     // Start and wait for d-tor.
     audio_processor.StartEchoCancellationDump(base::File(
         temp_file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN));
   }

   // Check that dump file is non-empty after audio processor has been
   // destroyed. Note that this test fails when compiling WebRTC
   // without protobuf support, rtc_enable_protobuf=false.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(temp_file_path, &output));
   ASSERT_FALSE(output.empty());
   // The temporary file is deleted when temp_directory exists scope.
 }

 }  // namespace media
	// Copyright 2018 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 <stddef.h>
	#include <stdint.h>

	#include <string>
	#include <vector>

	#include "base/files/file_path.h"
	#include "base/files/file_util.h"
	#include "base/files/scoped_temp_dir.h"
	#include "base/logging.h"
	#include "base/macros.h"
	#include "base/memory/aligned_memory.h"
	#include "base/path_service.h"
	#include "base/stl_util.h"
	#include "base/test/scoped_task_environment.h"
	#include "base/threading/thread_task_runner_handle.h"
	#include "base/time/time.h"
	#include "build/build_config.h"
	#include "media/base/audio_bus.h"
	#include "media/base/audio_parameters.h"
	#include "media/webrtc/audio_processor.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	using ::testing::_;
	using ::testing::AnyNumber;
	using ::testing::AtLeast;
	using ::testing::Return;

	namespace media {

	namespace {

	const int kAudioProcessingSampleRate = 48000;
	const int kAudioProcessingNumberOfChannels = 1;

	// The number of packers used for testing.
	const int kNumberOfPacketsForTest = 100;
	const int kMaxNumberOfPlayoutDataChannels = 2;

	void ReadDataFromSpeechFile(char* data, int length) {
	base::FilePath file;
	CHECK(base::PathService::Get(base::DIR_SOURCE_ROOT, &file));
	file = file.Append(FILE_PATH_LITERAL("media"))
	.Append(FILE_PATH_LITERAL("test"))
	.Append(FILE_PATH_LITERAL("data"))
	.Append(FILE_PATH_LITERAL("speech_16b_stereo_48kHz.raw"));
	DCHECK(base::PathExists(file));
	int64_t data_file_size64 = 0;
	DCHECK(base::GetFileSize(file, &data_file_size64));
	EXPECT_EQ(length, base::ReadFile(file, data, length));
	DCHECK(data_file_size64 > length);
	}

	} // namespace

	class WebRtcAudioProcessorTest : public ::testing::Test {
	public:
	WebRtcAudioProcessorTest()
	: params_(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	media::CHANNEL_LAYOUT_STEREO,
	48000,
	480) {}

	protected:
	// Helper method to save duplicated code.
	void ProcessDataAndVerifyFormat(AudioProcessor* audio_processor,
	int expected_output_sample_rate,
	int expected_output_channels,
	int expected_output_buffer_size) {
	// Read the audio data from a file.
	const media::AudioParameters& params = audio_processor->audio_parameters_;
	const int packet_size = params.frames_per_buffer() * 2 * params.channels();
	const size_t length = packet_size * kNumberOfPacketsForTest;
	std::unique_ptr<char[]> capture_data(new char[length]);
	ReadDataFromSpeechFile(capture_data.get(), length);
	const int16_t* data_ptr =
	reinterpret_cast<const int16_t*>(capture_data.get());
	std::unique_ptr<media::AudioBus> data_bus =
	media::AudioBus::Create(params.channels(), params.frames_per_buffer());

	// \|data_bus_playout\| is used if the number of capture channels is larger
	// than max allowed playout channels. \|data_bus_playout_to_use\| points to
	// the AudioBus to use, either \|data_bus\| or \|data_bus_playout\|.
	std::unique_ptr<media::AudioBus> data_bus_playout;
	media::AudioBus* data_bus_playout_to_use = data_bus.get();
	media::AudioParameters playout_params = params;
	if (params.channels() > kMaxNumberOfPlayoutDataChannels) {
	data_bus_playout =
	media::AudioBus::CreateWrapper(kMaxNumberOfPlayoutDataChannels);
	data_bus_playout->set_frames(params.frames_per_buffer());
	data_bus_playout_to_use = data_bus_playout.get();
	playout_params.Reset(params.format(), CHANNEL_LAYOUT_STEREO,
	params.sample_rate(), params.frames_per_buffer());
	}

	const base::TimeDelta input_capture_delay =
	base::TimeDelta::FromMilliseconds(20);
	for (int i = 0; i < kNumberOfPacketsForTest; ++i) {
	data_bus->FromInterleaved(data_ptr, data_bus->frames(), 2);
	// \|audio_processor\| does nothing when the audio processing is off in
	// the processor.
	webrtc::AudioProcessing* ap = audio_processor->audio_processing_.get();
	const bool is_aec_enabled = ap && ap->GetConfig().echo_canceller.enabled;
	if (is_aec_enabled) {
	if (params.channels() > kMaxNumberOfPlayoutDataChannels) {
	for (int i = 0; i < kMaxNumberOfPlayoutDataChannels; ++i) {
	data_bus_playout->SetChannelData(
	i, const_cast<float*>(data_bus->channel(i)));
	}
	}
	base::TimeTicks in_the_future =
	base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(10);
	audio_processor->AnalyzePlayout(*data_bus_playout_to_use,
	playout_params, in_the_future);
	}

	auto result = audio_processor->ProcessCapture(
	*data_bus, base::TimeTicks::Now() - input_capture_delay, 1.0, false);
	data_ptr += params.frames_per_buffer() * params.channels();
	}
	}

	void VerifyEnabledComponents(AudioProcessor* audio_processor) {
	webrtc::AudioProcessing* audio_processing =
	audio_processor->audio_processing_.get();
	webrtc::AudioProcessing::Config ap_config = audio_processing->GetConfig();
	EXPECT_TRUE(ap_config.echo_canceller.enabled);
	EXPECT_FALSE(ap_config.echo_canceller.mobile_mode);
	EXPECT_TRUE(ap_config.high_pass_filter.enabled);

	EXPECT_TRUE(audio_processing->noise_suppression()->is_enabled());
	EXPECT_TRUE(audio_processing->noise_suppression()->level() ==
	webrtc::NoiseSuppression::kHigh);
	EXPECT_TRUE(audio_processing->gain_control()->is_enabled());
	EXPECT_TRUE(audio_processing->gain_control()->mode() ==
	webrtc::GainControl::kAdaptiveAnalog);
	EXPECT_TRUE(audio_processing->voice_detection()->is_enabled());
	EXPECT_TRUE(audio_processing->voice_detection()->likelihood() ==
	webrtc::VoiceDetection::kVeryLowLikelihood);
	}

	AudioProcessingSettings GetEnabledAudioProcessingSettings() const {
	AudioProcessingSettings settings;
	settings.echo_cancellation = EchoCancellationType::kAec2;
	settings.noise_suppression = NoiseSuppressionType::kExperimental;
	settings.automatic_gain_control = AutomaticGainControlType::kExperimental;
	settings.high_pass_filter = true;
	settings.typing_detection = true;
	return settings;
	}

	base::test::ScopedTaskEnvironment scoped_task_environment_;
	media::AudioParameters params_;
	};

	TEST_F(WebRtcAudioProcessorTest, WithAudioProcessing) {
	AudioProcessor audio_processor(params_, GetEnabledAudioProcessingSettings());
	VerifyEnabledComponents(&audio_processor);
	ProcessDataAndVerifyFormat(&audio_processor, kAudioProcessingSampleRate,
	kAudioProcessingNumberOfChannels,
	kAudioProcessingSampleRate / 100);
	}

	TEST_F(WebRtcAudioProcessorTest, WithoutAnyProcessing) {
	// All processing settings are disabled by default
	AudioProcessingSettings settings;
	const media::AudioParameters source_params(
	media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	media::CHANNEL_LAYOUT_STEREO, kAudioProcessingSampleRate,
	kAudioProcessingSampleRate / 100);
	AudioProcessor audio_processor(source_params, settings);

	ProcessDataAndVerifyFormat(&audio_processor, params_.sample_rate(),
	params_.channels(), params_.sample_rate() / 100);
	}

	TEST_F(WebRtcAudioProcessorTest, TestAllSampleRates) {
	for (int sample_rate : {8000, 16000, 32000, 44100, 48000}) {
	int buffer_size = sample_rate / 100;
	media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	media::CHANNEL_LAYOUT_STEREO, sample_rate,
	buffer_size);
	AudioProcessor audio_processor(params, GetEnabledAudioProcessingSettings());

	VerifyEnabledComponents(&audio_processor);

	ProcessDataAndVerifyFormat(&audio_processor, kAudioProcessingSampleRate,
	kAudioProcessingNumberOfChannels,
	kAudioProcessingSampleRate / 100);
	}
	}

	TEST_F(WebRtcAudioProcessorTest, TestStereoAudio) {
	// All processing settings are disabled by default
	AudioProcessingSettings settings;
	settings.stereo_mirroring = true;
	const media::AudioParameters source_params(
	media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	media::CHANNEL_LAYOUT_STEREO, kAudioProcessingSampleRate,
	kAudioProcessingSampleRate / 100);
	AudioProcessor audio_processor(source_params, settings);

	// Construct left and right channels, and assign different values to the
	// first data of the left channel and right channel.
	const int size = media::AudioBus::CalculateMemorySize(source_params);
	std::unique_ptr<float, base::AlignedFreeDeleter> left_channel(
	static_cast<float*>(base::AlignedAlloc(size, 32)));
	std::unique_ptr<float, base::AlignedFreeDeleter> right_channel(
	static_cast<float*>(base::AlignedAlloc(size, 32)));
	std::unique_ptr<media::AudioBus> wrapper =
	media::AudioBus::CreateWrapper(source_params.channels());
	wrapper->set_frames(source_params.frames_per_buffer());
	wrapper->SetChannelData(0, left_channel.get());
	wrapper->SetChannelData(1, right_channel.get());
	wrapper->Zero();
	float* left_channel_ptr = left_channel.get();
	left_channel_ptr[0] = 1.0f;

	// Run the test consecutively to make sure the stereo channels are not
	// flipped back and forth.
	static const int kNumberOfPacketsForTest = 100;
	const base::TimeDelta pushed_capture_delay =
	base::TimeDelta::FromMilliseconds(42);
	for (int i = 0; i < kNumberOfPacketsForTest; ++i) {
	auto result = audio_processor.ProcessCapture(
	*wrapper, base::TimeTicks::Now() + pushed_capture_delay, 1.0, false);

	EXPECT_EQ(result.audio.channel(0)[0], 0);
	EXPECT_NE(result.audio.channel(1)[0], 0);
	}
	}

	TEST_F(WebRtcAudioProcessorTest, TestWithKeyboardMicChannel) {
	AudioProcessingSettings settings = GetEnabledAudioProcessingSettings();
	media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
	media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
	kAudioProcessingSampleRate,
	kAudioProcessingSampleRate / 100);
	AudioProcessor audio_processor(params, settings);
	ProcessDataAndVerifyFormat(&audio_processor, kAudioProcessingSampleRate,
	kAudioProcessingNumberOfChannels,
	kAudioProcessingSampleRate / 100);
	}

	TEST_F(WebRtcAudioProcessorTest, StartStopAecDump) {
	base::ScopedTempDir temp_directory;
	ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
	base::FilePath temp_file_path;
	ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_directory.GetPath(),
	&temp_file_path));
	{
	AudioProcessor audio_processor(params_,
	GetEnabledAudioProcessingSettings());

	// Start and stop recording.
	audio_processor.StartEchoCancellationDump(base::File(
	temp_file_path, base::File::FLAG_WRITE \| base::File::FLAG_OPEN));
	audio_processor.StopEchoCancellationDump();

	// Start and wait for d-tor.
	audio_processor.StartEchoCancellationDump(base::File(
	temp_file_path, base::File::FLAG_WRITE \| base::File::FLAG_OPEN));
	}

	// Check that dump file is non-empty after audio processor has been
	// destroyed. Note that this test fails when compiling WebRTC
	// without protobuf support, rtc_enable_protobuf=false.
	std::string output;
	ASSERT_TRUE(base::ReadFileToString(temp_file_path, &output));
	ASSERT_FALSE(output.empty());
	// The temporary file is deleted when temp_directory exists scope.
	}

	} // namespace media