Make AudioDebugFileWriter create its own file worker thread.

media/audio/audio_input_controller.cc

 // Copyright (c) 2012 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_input_controller.h"
 
 #include <inttypes.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 161 matching lines @@
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = nullptr;
 
 AudioInputController::AudioInputController(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     EventHandler* handler,
     SyncWriter* sync_writer,
     UserInputMonitor* user_input_monitor,
     const AudioParameters& params,
-    StreamType type,
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
+    StreamType type)
     : creator_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       task_runner_(std::move(task_runner)),
       handler_(handler),
       stream_(nullptr),
       sync_writer_(sync_writer),
       type_(type),
       user_input_monitor_(user_input_monitor),
 #if BUILDFLAG(ENABLE_WEBRTC)
-      debug_recording_helper_(params,
-                              task_runner_,
-                              std::move(file_task_runner),
-                              base::OnceClosure()),
+      debug_recording_helper_(params, task_runner_, base::OnceClosure()),
 #endif
       weak_ptr_factory_(this) {
   DCHECK(creator_task_runner_.get());
   DCHECK(handler_);
   DCHECK(sync_writer_);
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(!audio_callback_);
   DCHECK(!stream_);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     SyncWriter* sync_writer,
     UserInputMonitor* user_input_monitor,
     const AudioParameters& params,
     const std::string& device_id,
-    bool enable_agc,
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
+    bool enable_agc) {
   DCHECK(audio_manager);
   DCHECK(sync_writer);
   DCHECK(event_handler);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
     return nullptr;
 
   if (factory_) {
     return factory_->Create(audio_manager->GetTaskRunner(), sync_writer,
                             audio_manager, event_handler, params,
                             user_input_monitor, ParamsToStreamType(params));
   }
 
   // Create the AudioInputController object and ensure that it runs on
   // the audio-manager thread.
   scoped_refptr<AudioInputController> controller(new AudioInputController(
       audio_manager->GetTaskRunner(), event_handler, sync_writer,
-      user_input_monitor, params, ParamsToStreamType(params),
-      std::move(file_task_runner)));
+      user_input_monitor, params, ParamsToStreamType(params)));
 
   // Create and open a new audio input stream from the existing
   // audio-device thread. Use the provided audio-input device.
   if (!controller->task_runner_->PostTask(
           FROM_HERE, base::Bind(&AudioInputController::DoCreate, controller,
                                 base::Unretained(audio_manager), params,
                                 device_id, enable_agc))) {
     controller = nullptr;
   }
 
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     EventHandler* event_handler,
     AudioInputStream* stream,
     SyncWriter* sync_writer,
     UserInputMonitor* user_input_monitor,
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     const AudioParameters& params) {
   DCHECK(sync_writer);
   DCHECK(stream);
   DCHECK(event_handler);
 
   if (factory_) {
     return factory_->Create(task_runner, sync_writer, AudioManager::Get(),
                             event_handler,
                             AudioParameters::UnavailableDeviceParams(),
                             user_input_monitor, VIRTUAL);
   }
 
   // Create the AudioInputController object and ensure that it runs on
   // the audio-manager thread.
-  scoped_refptr<AudioInputController> controller(new AudioInputController(
-      task_runner, event_handler, sync_writer, user_input_monitor, params,
-      VIRTUAL, std::move(file_task_runner)));
+  scoped_refptr<AudioInputController> controller(
+      new AudioInputController(task_runner, event_handler, sync_writer,
+                               user_input_monitor, params, VIRTUAL));
 
   if (!controller->task_runner_->PostTask(
           FROM_HERE, base::Bind(&AudioInputController::DoCreateForStream,
                                 controller, stream, /*enable_agc*/ false))) {
     controller = nullptr;
   }
 
   return controller;
 }
 
@@ skipping 383 matching lines @@
     case AudioParameters::Format::AUDIO_PCM_LOW_LATENCY:
       return AudioInputController::StreamType::LOW_LATENCY;
     default:
       // Currently, the remaining supported type is fake. Reconsider if other
       // formats become supported.
       return AudioInputController::StreamType::FAKE;
   }
 }
 
 }  // namespace media