Make AudioDebugFileWriter create its own file worker thread.

media/audio/audio_debug_file_writer_unittest.cc

 // Copyright 2015 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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_byteorder.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread.h"
 #include "media/audio/audio_debug_file_writer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_sample_types.h"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 namespace {
@@ skipping 126 matching lines @@
       int read = file.Read(kWavHeaderSize,
                            reinterpret_cast<char*>(result_interleaved.get()),
                            source_samples_ * kBytesPerSample);
       EXPECT_EQ(static_cast<int>(file.GetLength() - kWavHeaderSize), read);
 
       VerifyDataRecording(source_interleaved_.get(), result_interleaved.get(),
                           source_samples_);
     }
   }
 
-  void TestDoneOnFileThread(const base::Closure& callback) {
-    DCHECK(file_thread_.task_runner()->BelongsToCurrentThread());
-
-    callback.Run();
-  }
-
   void DoDebugRecording() {
     // Write tasks are posted to |file_thread_|.
     for (int i = 0; i < writes_; ++i) {
       std::unique_ptr<AudioBus> bus =
           AudioBus::Create(params_.channels(), params_.frames_per_buffer());
 
       bus->FromInterleaved<media::SignedInt16SampleTypeTraits>(
           source_interleaved_.get() +
               i * params_.channels() * params_.frames_per_buffer(),
           params_.frames_per_buffer());
 
       debug_writer_->Write(std::move(bus));
     }
   }
 
-  void WaitForRecordingCompletion() {
-    WaitableMessageLoopEvent event;
-
-    // Post a task to the file thread indicating that all the writes are done.
-    file_thread_.task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&AudioDebugFileWriterTest::TestDoneOnFileThread,
-                   base::Unretained(this), event.GetClosure()));
-
-    // Wait for TestDoneOnFileThread() to call event's closure.
-    event.RunAndWait();
-  }
+  void WaitForRecordingCompletion() { scoped_task_environment_.RunUntilIdle(); }

[gab, 2017/05/18 16:10:10]

inline scoped_task_environment_.RunUntilIdle() instead of
WaitForRecordingCompletion() below and remove this method

[Sébastien Marchand, 2017/05/20 00:28:22]

Done.

 
   void RecordAndVerifyOnce() {
     base::FilePath file_path;
     EXPECT_TRUE(base::CreateTemporaryFile(&file_path));
 
     debug_writer_->Start(file_path);
 
     DoDebugRecording();
 
     debug_writer_->Stop();
 
     WaitForRecordingCompletion();
 
     VerifyRecording(file_path);
 
     if (::testing::Test::HasFailure()) {
       LOG(ERROR) << "Test failed; keeping recording(s) at ["
                  << file_path.value().c_str() << "].";
     } else {
       EXPECT_TRUE(base::DeleteFile(file_path, false));
     }
   }
 
  protected:
   // |file_thread_| must to be declared before |debug_writer_| so that it's
   // destroyed after. This ensures all tasks posted in |debug_writer_| to the
   // file thread are run before exiting the test.
   base::Thread file_thread_;
 
-  // Message loop for the test main thread.
-  base::MessageLoop message_loop_;
+  // The test task environment.
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
 
   // Writer under test.
   std::unique_ptr<AudioDebugFileWriter> debug_writer_;
 
   // AudioBus parameters.
   AudioParameters params_;
 
   // Number of times to write AudioBus to the file.
   int writes_;
 
   // Number of samples in the source data.
   int source_samples_;
 
   // Source data.
   std::unique_ptr<int16_t[]> source_interleaved_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioDebugFileWriterTest);
 };
 
 class AudioDebugFileWriterBehavioralTest : public AudioDebugFileWriterTest {};
 
 TEST_P(AudioDebugFileWriterTest, WaveRecordingTest) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
   RecordAndVerifyOnce();
 }
 
 TEST_P(AudioDebugFileWriterTest, GetFileNameExtension) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
   EXPECT_EQ(FILE_PATH_LITERAL("wav"),
             base::FilePath::StringType(debug_writer_->GetFileNameExtension()));
 }
 
 TEST_P(AudioDebugFileWriterBehavioralTest,
        DeletedBeforeRecordingFinishedOnFileThread) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
 
   base::FilePath file_path;
   EXPECT_TRUE(base::CreateTemporaryFile(&file_path));
 
   base::WaitableEvent* wait_for_deletion =
       new base::WaitableEvent(base::WaitableEvent::ResetPolicy::MANUAL,
                               base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   file_thread_.task_runner()->PostTask(
       FROM_HERE,
@@ skipping 12 matching lines @@
 
   if (::testing::Test::HasFailure()) {
     LOG(ERROR) << "Test failed; keeping recording(s) at ["
                << file_path.value().c_str() << "].";
   } else {
     EXPECT_TRUE(base::DeleteFile(file_path, false));
   }
 }
 
 TEST_P(AudioDebugFileWriterBehavioralTest, FileCreationError) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
   base::FilePath file_path;  // Empty file name.
   debug_writer_->Start(file_path);
   DoDebugRecording();
 }
 
 TEST_P(AudioDebugFileWriterBehavioralTest, StartStopStartStop) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
   RecordAndVerifyOnce();
   RecordAndVerifyOnce();
 }
 
 TEST_P(AudioDebugFileWriterBehavioralTest, DestroyNotStarted) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
   debug_writer_.reset();
 }
 
 TEST_P(AudioDebugFileWriterBehavioralTest, DestroyStarted) {
-  debug_writer_.reset(
-      new AudioDebugFileWriter(params_, file_thread_.task_runner()));
+  debug_writer_.reset(new AudioDebugFileWriter(params_));
   base::FilePath file_path;
   EXPECT_TRUE(base::CreateTemporaryFile(&file_path));
   debug_writer_->Start(file_path);
   debug_writer_.reset();
 }
 
 INSTANTIATE_TEST_CASE_P(
     AudioDebugFileWriterTest,
     AudioDebugFileWriterTest,
     // Using 10ms frames per buffer everywhere.
@@ skipping 34 matching lines @@
     AudioDebugFileWriterBehavioralTest,
     // Using 10ms frames per buffer everywhere.
     testing::Values(
         // No writes.
         std::tr1::make_tuple(ChannelLayout::CHANNEL_LAYOUT_MONO,
                              44100,
                              44100 / 100,
                              100)));
 
 }  // namespace media