Move AudioDebugFileWriter from content/ to media/.

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>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "media/base/media_switches.h"
 #include "media/base/user_input_monitor.h"
 
 namespace media {
 namespace {
 
 const int kMaxInputChannels = 3;
 
 #if defined(AUDIO_POWER_MONITORING)
 // Time in seconds between two successive measurements of audio power levels.
 const int kPowerMonitorLogIntervalSeconds = 15;
@@ skipping 103 matching lines @@
   void PerformOptionalDebugRecording(const AudioBus* source) {
     // Called on the hw callback thread while recording is enabled.
     if (!controller_->debug_writer_ || !controller_->debug_writer_->WillWrite())
       return;
 
     // TODO(tommi): This is costly. AudioBus heap allocs and we create a new
     // one for every callback. We could instead have a pool of bus objects
     // that get returned to us somehow.
     // We should also avoid calling PostTask here since the implementation
     // of the debug writer will basically do a PostTask straight away anyway.
-    // Might require some modifications to AudioFileWriter though since
-    // there are some threading concerns there and AudioFileWriter's
+    // Might require some modifications to AudioDebugFileWriter though since
+    // there are some threading concerns there and AudioDebugFileWriter's
     // lifetime guarantees need to be longer than that of associated active
     // audio streams.
     std::unique_ptr<AudioBus> source_copy =
         AudioBus::Create(source->channels(), source->frames());
     source->CopyTo(source_copy.get());
     controller_->task_runner_->PostTask(
         FROM_HERE, base::Bind(&AudioInputController::WriteInputDataForDebugging,
                               weak_controller_, base::Passed(&source_copy)));
   }
 
@@ skipping 31 matching lines @@
   bool error_during_callback_ = false;
 };
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = nullptr;
 
 AudioInputController::AudioInputController(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     EventHandler* handler,
     SyncWriter* sync_writer,
-    std::unique_ptr<AudioFileWriter> debug_writer,
     UserInputMonitor* user_input_monitor,
-    StreamType type)
+    const AudioParameters& params,
+    StreamType type,
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : 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),
-      debug_writer_(std::move(debug_writer)),
+#if BUILDFLAG(ENABLE_WEBRTC)
+      debug_writer_(
+          base::MakeUnique<AudioDebugFileWriter>(params,
+                                                 std::move(file_task_runner))),
+#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,
-    std::unique_ptr<AudioFileWriter> debug_writer,
     const AudioParameters& params,
     const std::string& device_id,
-    bool enable_agc) {
+    bool enable_agc,
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
   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,
-      std::move(debug_writer), user_input_monitor, ParamsToStreamType(params)));
+      user_input_monitor, params, ParamsToStreamType(params),
+      std::move(file_task_runner)));
 
   // 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,
-    std::unique_ptr<AudioFileWriter> debug_writer,
-    UserInputMonitor* user_input_monitor) {
+    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, std::move(debug_writer),
-      user_input_monitor, VIRTUAL));
+      task_runner, event_handler, sync_writer, user_input_monitor, params,
+      VIRTUAL, std::move(file_task_runner)));
 
   if (!controller->task_runner_->PostTask(
           FROM_HERE, base::Bind(&AudioInputController::DoCreateForStream,
                                 controller, stream, /*enable_agc*/ false))) {
     controller = nullptr;
   }
 
   return controller;
 }
 
@@ skipping 385 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