Make AudioDebugFileWriter create its own file worker thread.

media/audio/audio_debug_recording_manager_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_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 40 matching lines @@
 };
 
 }  // namespace
 
 // Mock class to verify enable and disable calls.
 class MockAudioDebugRecordingHelper : public AudioDebugRecordingHelper {
  public:
   MockAudioDebugRecordingHelper(
       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),
                                   base::OnceClosure()),
         on_destruction_closure_in_mock_(std::move(on_destruction_closure)) {
     if (g_expect_enable_after_create_helper)
       EXPECT_CALL(*this, EnableDebugRecording(_));
   }
 
   ~MockAudioDebugRecordingHelper() override {
     if (on_destruction_closure_in_mock_)
       std::move(on_destruction_closure_in_mock_).Run();
   }
 
   MOCK_METHOD1(EnableDebugRecording, void(const base::FilePath&));
   MOCK_METHOD0(DisableDebugRecording, void());
 
  private:
   // We let the mock run the destruction closure to not rely on the real
   // implementation.
   base::OnceClosure on_destruction_closure_in_mock_;
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioDebugRecordingHelper);
 };
 
 // Sub-class of the manager that overrides the CreateAudioDebugRecordingHelper
 // function to create the above mock instead.
 class AudioDebugRecordingManagerUnderTest : public AudioDebugRecordingManager {
  public:
   AudioDebugRecordingManagerUnderTest(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
-      : AudioDebugRecordingManager(std::move(task_runner),
-                                   std::move(file_task_runner)) {}
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : AudioDebugRecordingManager(std::move(task_runner)) {}
   ~AudioDebugRecordingManagerUnderTest() override {}
 
  private:
   std::unique_ptr<AudioDebugRecordingHelper> CreateAudioDebugRecordingHelper(
       const AudioParameters& params,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
       base::OnceClosure on_destruction_closure) override {
     return base::MakeUnique<MockAudioDebugRecordingHelper>(
-        params, std::move(task_runner), std::move(file_task_runner),
-        std::move(on_destruction_closure));
+        params, std::move(task_runner), std::move(on_destruction_closure));
   }
 
   DISALLOW_COPY_AND_ASSIGN(AudioDebugRecordingManagerUnderTest);
 };
 
 // The test fixture.
 class AudioDebugRecordingManagerTest : public ::testing::Test {
  public:
   AudioDebugRecordingManagerTest()
-      : manager_(message_loop_.task_runner(), message_loop_.task_runner()),
+      : manager_(message_loop_.task_runner()),
         base_file_path_(base::FilePath::FromUTF8Unsafe("base_path")) {}
 
   ~AudioDebugRecordingManagerTest() override {}
 
   // Registers a source and increases counter for the expected next source id.
   std::unique_ptr<AudioDebugRecorder> RegisterDebugRecordingSource(
       const AudioParameters& params) {
     ++expected_next_source_id_;
     return manager_.RegisterDebugRecordingSource(kFileNameExtension, params);
   }
@@ skipping 92 matching lines @@
   for (const auto& recorder : recorders) {
     MockAudioDebugRecordingHelper* mock_recording_helper =
         static_cast<MockAudioDebugRecordingHelper*>(recorder.get());
     EXPECT_CALL(*mock_recording_helper, DisableDebugRecording());
   }
 
   manager_.DisableDebugRecording();
 }
 
 }  // namespace media