Make AudioDebugFileWriter create its own file worker thread.

media/audio/audio_debug_recording_helper_unittest.cc

 // Copyright 2017 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 "media/audio/audio_debug_recording_helper.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/test/test_message_loop.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_sample_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Return;
 
 #if defined(OS_WIN)
@@ skipping 10 matching lines @@
 const base::FilePath::CharType kBaseFilePath[] = FILE_PATH_LITERAL("file_path");
 
 // The filename extension the mock should return in GetFileNameExtension().
 const base::FilePath::CharType kFileNameExtension[] = FILE_PATH_LITERAL("wav");
 
 }  // namespace
 
 // Mock class for the audio file writer that the helper wraps.
 class MockAudioDebugFileWriter : public AudioDebugFileWriter {
  public:
-  MockAudioDebugFileWriter(
-      const AudioParameters& params,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
-      : AudioDebugFileWriter(params, std::move(file_task_runner)),
-        reference_data_(nullptr) {}
+  MockAudioDebugFileWriter(const AudioParameters& params)
+      : AudioDebugFileWriter(params), reference_data_(nullptr) {}
   ~MockAudioDebugFileWriter() override {}
 
   MOCK_METHOD1(Start, void(const base::FilePath&));
   MOCK_METHOD0(Stop, void());
 
   // Functions with move-only types as arguments can't be mocked directly, so
   // we pass on to DoWrite(). Also, we can verify the data this way.
   MOCK_METHOD1(DoWrite, void(AudioBus*));
   void Write(std::unique_ptr<AudioBus> data) override {
     CHECK(reference_data_);
@@ skipping 25 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockAudioDebugFileWriter);
 };
 
 // Sub-class of the helper that overrides the CreateAudioDebugFileWriter
 // function to create the above mock instead.
 class AudioDebugRecordingHelperUnderTest : public AudioDebugRecordingHelper {
  public:
   AudioDebugRecordingHelperUnderTest(
       const AudioParameters& params,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
       base::OnceClosure on_destruction_closure)
       : AudioDebugRecordingHelper(params,
                                   std::move(task_runner),
-                                  std::move(file_task_runner),
                                   std::move(on_destruction_closure)) {}
   ~AudioDebugRecordingHelperUnderTest() override {}
 
  private:
   // Creates the mock writer. After the mock writer is returned, we always
   // expect GetFileNameExtension() and Start() to be called on it by the helper.
   std::unique_ptr<AudioDebugFileWriter> CreateAudioDebugFileWriter(
-      const AudioParameters& params,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) override {
-    MockAudioDebugFileWriter* writer =
-        new MockAudioDebugFileWriter(params, std::move(file_task_runner));
+      const AudioParameters& params) override {
+    MockAudioDebugFileWriter* writer = new MockAudioDebugFileWriter(params);
     EXPECT_CALL(*writer, GetFileNameExtension())
         .WillOnce(Return(kFileNameExtension));
     base::FilePath expected_file_path =
         base::FilePath(kBaseFilePath).AddExtension(kFileNameExtension);
     EXPECT_CALL(*writer, Start(expected_file_path));
     return base::WrapUnique<AudioDebugFileWriter>(writer);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AudioDebugRecordingHelperUnderTest);
 };
 
 // The test fixture.
 class AudioDebugRecordingHelperTest : public ::testing::Test {
  public:
   AudioDebugRecordingHelperTest() : file_path_(kBaseFilePath) {}
 
   ~AudioDebugRecordingHelperTest() override {}
 
   // Helper function that creates a recording helper.
   std::unique_ptr<AudioDebugRecordingHelper> CreateRecordingHelper(
       const AudioParameters& params,
       base::OnceClosure on_destruction_closure) {
     return base::MakeUnique<AudioDebugRecordingHelperUnderTest>(
-        params, message_loop_.task_runner(), message_loop_.task_runner(),
+        params, scoped_task_environment_.GetMainThreadTaskRunner(),
         std::move(on_destruction_closure));
   }
 
   // Helper function that unsets the mock writer pointer after disabling.
   void DisableDebugRecording(AudioDebugRecordingHelper* recording_helper) {
     recording_helper->DisableDebugRecording();
   }
 
   MOCK_METHOD0(OnAudioDebugRecordingHelperDestruction, void());
 
  protected:
   base::FilePath file_path_;
 
-  base::TestMessageLoop message_loop_;
+  // The test task environment.
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioDebugRecordingHelperTest);
 };
 
 // Creates a helper with an on destrcution closure, and verifies that it's
 // run.
 TEST_F(AudioDebugRecordingHelperTest, TestDestructionClosure) {
   const AudioParameters params;
   std::unique_ptr<AudioDebugRecordingHelper> recording_helper =
@@ skipping 92 matching lines @@
 
   EXPECT_CALL(*mock_audio_file_writer, Stop());
   DisableDebugRecording(recording_helper.get());
 
   // This call should not yield a DoWrite() call on the mock either.
   recording_helper->OnData(audio_bus.get());
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media