Audio output debug recording.

media/audio/audio_manager_base.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_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 66 matching lines @@
 
 AudioManagerBase::AudioManagerBase(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory)
     : AudioManager(std::move(task_runner), std::move(worker_task_runner)),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       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) {}
 
 AudioManagerBase::~AudioManagerBase() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   // All the output streams should have been deleted.
   CHECK_EQ(0, num_output_streams_);
   // All the input streams should have been deleted.
@@ skipping 179 matching lines @@
                    CompareByParams(dispatcher_params));
   if (it != output_dispatchers_.end()) {
     delete dispatcher_params;
     return (*it)->dispatcher->CreateStreamProxy();
   }
 
   const base::TimeDelta kCloseDelay =
       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
   std::unique_ptr<AudioOutputDispatcher> dispatcher;
   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
+    // If |debug_recording_manager_| is set we tell AudioOutputResampler to
+    // register sources with it.
+    AudioOutputResampler::RegisterDebugRecordingSourceCallback
+        register_debug_recording_source_callback;
+    if (debug_recording_manager_) {
+      // Using unretained is safe since |debug_recording_manager_|
+      // outlives the dispatchers (cleared in Shutdown()).
+      register_debug_recording_source_callback = base::BindRepeating(
+          &AudioDebugRecordingManager::RegisterDebugRecordingSource,
+          base::Unretained(debug_recording_manager_.get()), "output");
+    }
     dispatcher = base::MakeUnique<AudioOutputResampler>(
-        this, params, output_params, output_device_id, kCloseDelay);
+        this, params, output_params, output_device_id, kCloseDelay,
+        register_debug_recording_source_callback);

[o1ka, 2017/02/09 13:04:03]

just (debug_recording_manager_) ?  base::BindRepeating(
&AudioDebugRecordingManager::RegisterDebugRecordingSource,
          base::Unretained(debug_recording_manager_.get()), "output") : ... ?

it can also be a helper static of AudioDebugRecordingManager.

[Henrik Grunell, 2017/02/10 09:00:56]

Done.
Not sure how you mean.

   } else {
     dispatcher = base::MakeUnique<AudioOutputDispatcherImpl>(
         this, output_params, output_device_id, kCloseDelay);
   }
 
   dispatcher_params->dispatcher = std::move(dispatcher);
   output_dispatchers_.push_back(dispatcher_params);
   return dispatcher_params->dispatcher->CreateStreamProxy();
 }
 
@@ skipping 126 matching lines @@
     return buffer_size;
 
   return 0;
 }
 
 std::unique_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return audio_log_factory_->CreateAudioLog(component);
 }
 
+void AudioManagerBase::InitializeOutputDebugRecording(
+    CreateAudioFileWriterCallback create_audio_file_writer_callback) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(!debug_recording_manager_);
+  debug_recording_manager_ = base::MakeUnique<AudioDebugRecordingManager>(
+      create_audio_file_writer_callback, GetTaskRunner());
+}
+
+void AudioManagerBase::EnableOutputDebugRecording(
+    const base::FilePath& base_file_name) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  debug_recording_manager_->EnableDebugRecording(base_file_name);

[o1ka, 2017/02/09 13:04:03]

if (debug_recording_manager_)?
Looks like unit test is needed.

[Henrik Grunell, 2017/02/10 09:00:56]

I wrote answer in a previous comment answer. :) The intention is that
InitializeOutputDebugRecording() must be called before Enable(). I.e. crashing
is intentional.

Anyway, added unit test case for these functions.

[o1ka, 2017/02/10 15:21:53]

This intention is not obvious at all.
DCHECK(debug_recording_manager_) << "InitializeOutputDebugRecording() must be
called before Enable()"
 ?

[Henrik Grunell, 2017/02/13 15:16:48]

Yeah, it's only in the header comment in AudioManager (fixed a missing word
there now). Added the dcheck here.

+}
+
+void AudioManagerBase::DisableOutputDebugRecording() {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  if (debug_recording_manager_)
+    debug_recording_manager_->DisableDebugRecording();
+}
+
 void AudioManagerBase::SetMaxStreamCountForTesting(int max_input,
                                                    int max_output) {
   max_num_output_streams_ = max_output;
   max_num_input_streams_ = max_input;
 }
 
 }  // namespace media