[media/audio] Convert VLOGs to DVLOGs

media/audio/android/audio_android_unittest.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 "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 73 matching lines @@
 
 static double ExpectedTimeBetweenCallbacks(AudioParameters params) {
   return (base::TimeDelta::FromMicroseconds(
               params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
               static_cast<double>(params.sample_rate()))).InMillisecondsF();
 }
 
 // Helper method which verifies that the device list starts with a valid
 // default device name followed by non-default device names.
 static void CheckDeviceNames(const AudioDeviceNames& device_names) {
-  VLOG(2) << "Got " << device_names.size() << " audio devices.";
+  DVLOG(2) << "Got " << device_names.size() << " audio devices.";
   if (device_names.empty()) {
     // Log a warning so we can see the status on the build bots.  No need to
     // break the test though since this does successfully test the code and
     // some failure cases.
     LOG(WARNING) << "No input devices detected";
     return;
   }
 
   AudioDeviceNames::const_iterator it = device_names.begin();
 
   // The first device in the list should always be the default device.
   EXPECT_EQ(std::string(AudioManagerBase::kDefaultDeviceName),
             it->device_name);
   EXPECT_EQ(std::string(AudioManagerBase::kDefaultDeviceId), it->unique_id);
   ++it;
 
   // Other devices should have non-empty name and id and should not contain
   // default name or id.
   while (it != device_names.end()) {
     EXPECT_FALSE(it->device_name.empty());
     EXPECT_FALSE(it->unique_id.empty());
-    VLOG(2) << "Device ID(" << it->unique_id
-            << "), label: " << it->device_name;
+    DVLOG(2) << "Device ID(" << it->unique_id
+             << "), label: " << it->device_name;
     EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceName),
               it->device_name);
     EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceId),
               it->unique_id);
     ++it;
   }
 }
 
 // We clear the data bus to ensure that the test does not cause noise.
 static int RealOnMoreData(AudioBus* dest, uint32 total_bytes_delay) {
@@ skipping 34 matching lines @@
 class FileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit FileAudioSource(base::WaitableEvent* event, const std::string& name)
       : event_(event), pos_(0) {
     // Reads a test file from media/test/data directory and stores it in
     // a DecoderBuffer.
     file_ = ReadTestDataFile(name);
 
     // Log the name of the file which is used as input for this test.
     base::FilePath file_path = GetTestDataFilePath(name);
-    VLOG(0) << "Reading from file: " << file_path.value().c_str();
+    DVLOG(0) << "Reading from file: " << file_path.value().c_str();
   }
 
   virtual ~FileAudioSource() {}
 
   // AudioOutputStream::AudioSourceCallback implementation.
 
   // Use samples read from a data file and fill up the audio buffer
   // provided to us in the callback.
   virtual int OnMoreData(AudioBus* audio_bus,
                          uint32 total_bytes_delay) override {
@@ skipping 50 matching lines @@
     // Allocate space for ~10 seconds of data.
     const int kMaxBufferSize = 10 * params.GetBytesPerSecond();
     buffer_.reset(new media::SeekableBuffer(0, kMaxBufferSize));
 
     // Open up the binary file which will be written to in the destructor.
     base::FilePath file_path;
     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
     file_path = file_path.AppendASCII(file_name.c_str());
     binary_file_ = base::OpenFile(file_path, "wb");
     DLOG_IF(ERROR, !binary_file_) << "Failed to open binary PCM data file.";
-    VLOG(0) << "Writing to file: " << file_path.value().c_str();
+    DVLOG(0) << "Writing to file: " << file_path.value().c_str();
   }
 
   virtual ~FileAudioSink() {
     int bytes_written = 0;
     while (bytes_written < buffer_->forward_capacity()) {
       const uint8* chunk;
       int chunk_size;
 
       // Stop writing if no more data is available.
       if (!buffer_->GetCurrentChunk(&chunk, &chunk_size))
@@ skipping 251 matching lines @@
     OpenAndStartAudioOutputStreamOnAudioThread(&source);
 
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
 
     StopAndCloseAudioOutputStreamOnAudioThread();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
-    VLOG(0) << "expected time between callbacks: "
-            << expected_time_between_callbacks_ms << " ms";
-    VLOG(0) << "average time between callbacks: "
-            << average_time_between_callbacks_ms << " ms";
+    DVLOG(0) << "expected time between callbacks: "
+             << expected_time_between_callbacks_ms << " ms";
+    DVLOG(0) << "average time between callbacks: "
+             << average_time_between_callbacks_ms << " ms";
     EXPECT_GE(average_time_between_callbacks_ms,
               0.70 * expected_time_between_callbacks_ms);
     EXPECT_LE(average_time_between_callbacks_ms,
               1.50 * expected_time_between_callbacks_ms);
   }
 
   void GetDefaultOutputStreamParameters() {
     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
     audio_output_parameters_ =
         audio_manager()->GetDefaultOutputStreamParameters();
@@ skipping 130 matching lines @@
     OpenAndStartAudioInputStreamOnAudioThread(&sink);
 
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
 
     StopAndCloseAudioInputStreamOnAudioThread();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
-    VLOG(0) << "expected time between callbacks: "
-            << expected_time_between_callbacks_ms << " ms";
-    VLOG(0) << "average time between callbacks: "
-            << average_time_between_callbacks_ms << " ms";
+    DVLOG(0) << "expected time between callbacks: "
+             << expected_time_between_callbacks_ms << " ms";
+    DVLOG(0) << "average time between callbacks: "
+             << average_time_between_callbacks_ms << " ms";
     EXPECT_GE(average_time_between_callbacks_ms,
               0.70 * expected_time_between_callbacks_ms);
     EXPECT_LE(average_time_between_callbacks_ms,
               1.30 * expected_time_between_callbacks_ms);
   }
 
   void GetDefaultInputStreamParameters() {
     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
     audio_input_parameters_ = audio_manager()->GetInputStreamParameters(
         AudioManagerBase::kDefaultDeviceId);
@@ skipping 32 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioAndroidInputTest);
 };
 
 // Get the default audio input parameters and log the result.
 TEST_P(AudioAndroidInputTest, GetDefaultInputStreamParameters) {
   // We don't go through AudioAndroidInputTest::GetInputStreamParameters() here
   // so that we can log the real (non-overridden) values of the effects.
   GetDefaultInputStreamParametersOnAudioThread();
   EXPECT_TRUE(audio_input_parameters().IsValid());
-  VLOG(1) << audio_input_parameters();
+  DVLOG(1) << audio_input_parameters();
 }
 
 // Get the default audio output parameters and log the result.
 TEST_F(AudioAndroidOutputTest, GetDefaultOutputStreamParameters) {
   GetDefaultOutputStreamParametersOnAudioThread();
-  VLOG(1) << audio_output_parameters();
+  DVLOG(1) << audio_output_parameters();
 }
 
 // Verify input device enumeration.
 TEST_F(AudioAndroidInputTest, GetAudioInputDeviceNames) {
   if (!audio_manager()->HasAudioInputDevices())
     return;
   AudioDeviceNames devices;
   RunOnAudioThread(
       base::Bind(&AudioManager::GetAudioInputDeviceNames,
                  base::Unretained(audio_manager()),
@@ skipping 91 matching lines @@
                          audio_output_parameters().sample_rate() / 100);
   StartOutputStreamCallbacks(params);
 }
 
 // Play out a PCM file segment in real time and allow the user to verify that
 // the rendered audio sounds OK.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_F(AudioAndroidOutputTest, DISABLED_RunOutputStreamWithFileAsSource) {
   GetDefaultOutputStreamParametersOnAudioThread();
-  VLOG(1) << audio_output_parameters();
+  DVLOG(1) << audio_output_parameters();
   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
 
   std::string file_name;
   const AudioParameters params = audio_output_parameters();
   if (params.sample_rate() == 48000 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_48k;
   } else if (params.sample_rate() == 48000 && params.channels() == 1) {
     file_name = kSpeechFile_16b_m_48k;
   } else if (params.sample_rate() == 44100 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_44k;
   } else if (params.sample_rate() == 44100 && params.channels() == 1) {
     file_name = kSpeechFile_16b_m_44k;
   } else {
     FAIL() << "This test supports 44.1kHz and 48kHz mono/stereo only.";
     return;
   }
 
   base::WaitableEvent event(false, false);
   FileAudioSource source(&event, file_name);
 
   OpenAndStartAudioOutputStreamOnAudioThread(&source);
-  VLOG(0) << ">> Verify that the file is played out correctly...";
+  DVLOG(0) << ">> Verify that the file is played out correctly...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   StopAndCloseAudioOutputStreamOnAudioThread();
 }
 
 // Start input streaming and run it for ten seconds while recording to a
 // local audio file.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest, DISABLED_RunSimplexInputStreamWithFileAsSink) {
   AudioParameters params = GetInputStreamParameters();
-  VLOG(1) << params;
+  DVLOG(1) << params;
   MakeAudioInputStreamOnAudioThread(params);
 
   std::string file_name = base::StringPrintf("out_simplex_%d_%d_%d.pcm",
                                              params.sample_rate(),
                                              params.frames_per_buffer(),
                                              params.channels());
 
   base::WaitableEvent event(false, false);
   FileAudioSink sink(&event, params, file_name);
 
   OpenAndStartAudioInputStreamOnAudioThread(&sink);
-  VLOG(0) << ">> Speak into the microphone to record audio...";
+  DVLOG(0) << ">> Speak into the microphone to record audio...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 // Same test as RunSimplexInputStreamWithFileAsSink but this time output
 // streaming is active as well (reads zeros only).
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
   AudioParameters in_params = GetInputStreamParameters();
-  VLOG(1) << in_params;
+  DVLOG(1) << in_params;
   MakeAudioInputStreamOnAudioThread(in_params);
 
   GetDefaultOutputStreamParametersOnAudioThread();
-  VLOG(1) << audio_output_parameters();
+  DVLOG(1) << audio_output_parameters();
   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
 
   std::string file_name = base::StringPrintf("out_duplex_%d_%d_%d.pcm",
                                              in_params.sample_rate(),
                                              in_params.frames_per_buffer(),
                                              in_params.channels());
 
   base::WaitableEvent event(false, false);
   FileAudioSink sink(&event, in_params, file_name);
   MockAudioSourceCallback source;
 
   EXPECT_CALL(source, OnMoreData(NotNull(), _))
       .WillRepeatedly(Invoke(RealOnMoreData));
   EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
 
   OpenAndStartAudioInputStreamOnAudioThread(&sink);
   OpenAndStartAudioOutputStreamOnAudioThread(&source);
-  VLOG(0) << ">> Speak into the microphone to record audio";
+  DVLOG(0) << ">> Speak into the microphone to record audio";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 // Start audio in both directions while feeding captured data into a FIFO so
 // it can be read directly (in loopback) by the render side. A small extra
 // delay will be added by the FIFO and an estimate of this delay will be
 // printed out during the test.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest,
        DISABLED_RunSymmetricInputAndOutputStreamsInFullDuplex) {
   // Get native audio parameters for the input side.
   AudioParameters default_input_params = GetInputStreamParameters();
 
   // Modify the parameters so that both input and output can use the same
   // parameters by selecting 10ms as buffer size. This will also ensure that
   // the output stream will be a mono stream since mono is default for input
   // audio on Android.
   AudioParameters io_params(default_input_params.format(),
                             default_input_params.channel_layout(),
                             ChannelLayoutToChannelCount(
                                 default_input_params.channel_layout()),
                             default_input_params.sample_rate(),
                             default_input_params.bits_per_sample(),
                             default_input_params.sample_rate() / 100,
                             default_input_params.effects());
-  VLOG(1) << io_params;
+  DVLOG(1) << io_params;
 
   // Create input and output streams using the common audio parameters.
   MakeAudioInputStreamOnAudioThread(io_params);
   MakeAudioOutputStreamOnAudioThread(io_params);
 
   FullDuplexAudioSinkSource full_duplex(io_params);
 
   // Start a full duplex audio session and print out estimates of the extra
   // delay we should expect from the FIFO. If real-time delay measurements are
   // performed, the result should be reduced by this extra delay since it is
   // something that has been added by the test.
   OpenAndStartAudioInputStreamOnAudioThread(&full_duplex);
   OpenAndStartAudioOutputStreamOnAudioThread(&full_duplex);
-  VLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
-          << "once per second during this test.";
-  VLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
+  DVLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
+           << "once per second during this test.";
+  DVLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
   fflush(stdout);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media