Audio output debug recording.

media/audio/audio_manager.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.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
+#include "media/audio/fake_audio_file_writer.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_MACOSX)
 #include "media/audio/mac/audio_manager_mac.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #include "media/audio/win/core_audio_util_win.h"
@@ skipping 261 matching lines @@
   if (!instance->GetTaskRunner()->DeleteSoon(FROM_HERE, instance)) {
     LOG(WARNING) << "Failed to delete AudioManager instance.";
   }
 #endif
 }
 
 // Forward declaration of the platform specific AudioManager factory function.
 ScopedAudioManagerPtr CreateAudioManager(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
-    AudioLogFactory* audio_log_factory);
+    AudioLogFactory* audio_log_factory,
+    CreateAudioFileWriterCallback create_audio_file_writer_callback);
 
 void AudioManager::SetMaxStreamCountForTesting(int max_input, int max_output) {
   NOTREACHED();
 }
 
 AudioManager::AudioManager(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner)
     : task_runner_(std::move(task_runner)),
       worker_task_runner_(std::move(worker_task_runner)) {
@@ skipping 11 matching lines @@
 }
 
 AudioManager::~AudioManager() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 // static
 ScopedAudioManagerPtr AudioManager::Create(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
-    AudioLogFactory* audio_log_factory) {
+    AudioLogFactory* audio_log_factory,
+    CreateAudioFileWriterCallback create_audio_file_writer_callback) {
   DCHECK(task_runner);
   DCHECK(worker_task_runner);
   return CreateAudioManager(std::move(task_runner),
-                            std::move(worker_task_runner), audio_log_factory);
+                            std::move(worker_task_runner), audio_log_factory,
+                            std::move(create_audio_file_writer_callback));
 }
 
 // static
 ScopedAudioManagerPtr AudioManager::CreateForTesting(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
 #if defined(OS_WIN)
   g_helper.Pointer()->InitializeCOMForTesting();
 #endif
   return Create(task_runner, task_runner,
-                g_helper.Pointer()->fake_log_factory());
+                g_helper.Pointer()->fake_log_factory(),
+                base::Bind(&FakeAudioFileWriter::Create));
 }
 
 // static
 void AudioManager::StartHangMonitorIfNeeded(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   if (g_helper.Pointer()->monitor_task_runner())
     return;
 
   DCHECK(AudioManager::Get());
   DCHECK(task_runner);
@@ skipping 19 matching lines @@
   return g_helper.Pointer()->app_name();
 }
 #endif
 
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media