Audio output debug recording.

media/audio/audio_manager_base.cc

Index: media/audio/audio_manager_base.cc
diff --git a/media/audio/audio_manager_base.cc b/media/audio/audio_manager_base.cc
index 670820dc3a6ad0f446d429cd97b4e3a7484f5c67..d7e9cabe3f34086eb85de7d5d18c9c9e670b7d2b 100644
--- a/media/audio/audio_manager_base.cc
+++ b/media/audio/audio_manager_base.cc
@@ -36,6 +36,13 @@ const int kDefaultMaxInputStreams = 32;
 
 const int kMaxInputChannels = 3;
 
+// Helper function to pass as callback when the audio debug recording is not
+// enabled.
+std::unique_ptr<AudioDebugRecorder> GetNullptrAudioDebugRecorder(
+    const AudioParameters& params) {
+  return nullptr;
+}
+
 }  // namespace
 
 struct AudioManagerBase::DispatcherParams {
@@ -84,8 +91,7 @@ AudioManagerBase::AudioManagerBase(
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
       // TODO(dalecurtis): Switch this to an base::ObserverListThreadSafe, so we
-      // don't
-      // block the UI thread when swapping devices.
+      // don't block the UI thread when swapping devices.
       output_listeners_(
           base::ObserverList<AudioDeviceListener>::NOTIFY_EXISTING_ONLY),
       audio_log_factory_(audio_log_factory) {}
@@ -285,8 +291,16 @@ AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
   std::unique_ptr<AudioOutputDispatcher> dispatcher;
   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
+    // Using unretained for |debug_recording_manager_| is safe since it
+    // outlives the dispatchers (cleared in Shutdown()).
     dispatcher = base::MakeUnique<AudioOutputResampler>(
-        this, params, output_params, output_device_id, kCloseDelay);
+        this, params, output_params, output_device_id, kCloseDelay,
+        debug_recording_manager_
+            ? base::BindRepeating(
+                  &AudioDebugRecordingManager::RegisterDebugRecordingSource,
+                  base::Unretained(debug_recording_manager_.get()),
+                  FILE_PATH_LITERAL("output"))
+            : base::BindRepeating(&GetNullptrAudioDebugRecorder));
   } else {
     dispatcher = base::MakeUnique<AudioOutputDispatcherImpl>(
         this, output_params, output_device_id, kCloseDelay);
@@ -433,6 +447,45 @@ std::unique_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
   return audio_log_factory_->CreateAudioLog(component);
 }
 
+void AudioManagerBase::InitializeOutputDebugRecording(
+    AudioFileWriter::CreateCallback create_audio_file_writer_callback) {
+  if (!GetTaskRunner()->BelongsToCurrentThread()) {
+    // AudioManager is deleted on the audio thread, so it's safe to post
+    // unretained.
+    GetTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&AudioManager::InitializeOutputDebugRecording,
+                   base::Unretained(this), create_audio_file_writer_callback));

[o1ka, 2017/02/15 14:13:12]

move the callback?

[Henrik Grunell, 2017/02/16 11:45:09]

Done.

+    return;
+  }
+
+  DCHECK(!debug_recording_manager_);
+  debug_recording_manager_ = CreateAudioDebugRecordingManager(
+      create_audio_file_writer_callback, GetTaskRunner());
+}
+
+void AudioManagerBase::EnableOutputDebugRecording(
+    const base::FilePath& base_file_name) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(debug_recording_manager_)
+      << "InitializeOutputDebugRecording() must be called before enabling";
+  debug_recording_manager_->EnableDebugRecording(base_file_name);
+}
+
+void AudioManagerBase::DisableOutputDebugRecording() {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  if (debug_recording_manager_)
+    debug_recording_manager_->DisableDebugRecording();
+}
+
+std::unique_ptr<AudioDebugRecordingManager>
+AudioManagerBase::CreateAudioDebugRecordingManager(
+    AudioFileWriter::CreateCallback create_audio_file_writer_callback,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  return base::MakeUnique<AudioDebugRecordingManager>(
+      std::move(create_audio_file_writer_callback), std::move(task_runner));
+}
+
 void AudioManagerBase::SetMaxStreamCountForTesting(int max_input,
                                                    int max_output) {
   max_num_output_streams_ = max_output;