Replace LOG(INFO) with VLOG(0), throughout *media*

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/basictypes.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
@@ skipping 124 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);
-    LOG(INFO) << "Reading from file: " << file_path.value().c_str();
+    VLOG(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,
                          AudioBuffersState buffers_state) OVERRIDE {
@@ skipping 57 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_ = file_util::OpenFile(file_path, "wb");
     DLOG_IF(ERROR, !binary_file_) << "Failed to open binary PCM data file.";
-    LOG(INFO) << "Writing to file: " << file_path.value().c_str();
+    VLOG(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 202 matching lines @@
     EXPECT_TRUE(stream->Open());
     stream->Start(&sink);
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
     stream->Stop();
     stream->Close();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
-    LOG(INFO) << "expected time between callbacks: "
-              << expected_time_between_callbacks_ms << " ms";
-    LOG(INFO) << "average time between callbacks: "
-              << average_time_between_callbacks_ms << " ms";
+    VLOG(0) << "expected time between callbacks: "
+            << expected_time_between_callbacks_ms << " ms";
+    VLOG(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 StartOutputStreamCallbacks(const AudioParameters& params) {
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
@@ skipping 16 matching lines @@
     EXPECT_TRUE(stream->Open());
     stream->Start(&source);
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
     stream->Stop();
     stream->Close();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
-    LOG(INFO) << "expected time between callbacks: "
-              << expected_time_between_callbacks_ms << " ms";
-    LOG(INFO) << "average time between callbacks: "
-              << average_time_between_callbacks_ms << " ms";
+    VLOG(0) << "expected time between callbacks: "
+            << expected_time_between_callbacks_ms << " ms";
+    VLOG(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);
   }
 
   scoped_ptr<base::MessageLoopForUI> loop_;
   scoped_ptr<AudioManager> audio_manager_;
   base::TimeTicks start_time_;
   base::TimeTicks end_time_;
@@ skipping 13 matching lines @@
   AudioParameters params = GetDefaultOutputStreamParameters();
   EXPECT_TRUE(params.IsValid());
   VLOG(1) << params;
 }
 
 // Check if low-latency output is supported and log the result as output.
 TEST_F(AudioAndroidTest, IsAudioLowLatencySupported) {
   AudioManagerAndroid* manager =
       static_cast<AudioManagerAndroid*>(audio_manager());
   bool low_latency = manager->IsAudioLowLatencySupported();
-  low_latency ? LOG(INFO) << "Low latency output is supported"
-              : LOG(INFO) << "Low latency output is *not* supported";
+  low_latency ? VLOG(0) << "Low latency output is supported"
+              : VLOG(0) << "Low latency output is *not* supported";
 }
 
 // Ensure that a default input stream can be created and closed.
 TEST_F(AudioAndroidTest, CreateAndCloseInputStream) {
   AudioParameters params = GetDefaultInputStreamParameters();
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
   ais->Close();
 }
@@ skipping 97 matching lines @@
     FAIL() << "This test supports 44.1kHz and 48kHz mono/stereo only.";
     return;
   }
 
   base::WaitableEvent event(false, false);
   FileAudioSource source(&event, file_name);
 
   EXPECT_TRUE(aos->Open());
   aos->SetVolume(1.0);
   aos->Start(&source);
-  LOG(INFO) << ">> Verify that the file is played out correctly...";
+  VLOG(0) << ">> Verify that the file is played out correctly...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   aos->Stop();
   aos->Close();
 }
 
 // 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_F(AudioAndroidTest, DISABLED_RunSimplexInputStreamWithFileAsSink) {
   AudioParameters params = GetDefaultInputStreamParameters();
   VLOG(1) << params;
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
 
   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);
 
   EXPECT_TRUE(ais->Open());
   ais->Start(&sink);
-  LOG(INFO) << ">> Speak into the microphone to record audio...";
+  VLOG(0) << ">> Speak into the microphone to record audio...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   ais->Stop();
   ais->Close();
 }
 
 // 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_F(AudioAndroidTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
@@ skipping 19 matching lines @@
 
   EXPECT_CALL(source, OnMoreData(NotNull(), _)).WillRepeatedly(
       Invoke(&source, &MockAudioOutputCallback::RealOnMoreData));
   EXPECT_CALL(source, OnError(aos)).Times(0);
   EXPECT_CALL(source, OnMoreIOData(_, _, _)).Times(0);
 
   EXPECT_TRUE(ais->Open());
   EXPECT_TRUE(aos->Open());
   ais->Start(&sink);
   aos->Start(&source);
-  LOG(INFO) << ">> Speak into the microphone to record audio";
+  VLOG(0) << ">> Speak into the microphone to record audio";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   aos->Stop();
   ais->Stop();
   aos->Close();
   ais->Close();
 }
 
 // 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
@@ skipping 29 matching lines @@
   // 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.
   EXPECT_TRUE(ais->Open());
   EXPECT_TRUE(aos->Open());
   ais->Start(&full_duplex);
   aos->Start(&full_duplex);
   VLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
           << "once per second during this test.";
-  LOG(INFO) << ">> Speak into the mic and listen to the audio in loopback...";
+  VLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
   fflush(stdout);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   aos->Stop();
   ais->Stop();
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media