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"
@@ skipping 27 matching lines @@
 // The singleton instance of AudioManager. This is set when Create() is called.
 AudioManager* g_last_created = nullptr;
 
 // Maximum number of failed pings to the audio thread allowed. A UMA will be
 // recorded once this count is reached; if enabled, a non-crash dump will be
 // captured as well. We require at least three failed pings before recording to
 // ensure unobservable power events aren't mistakenly caught (e.g., the system
 // suspends before a OnSuspend() event can be fired).
 const int kMaxFailedPingsCount = 3;
 
+// Dummy function for creating debug writer.
+std::unique_ptr<AudioFileWriter> CreateAudioFileWriterDummy(
+    const AudioParameters& params) {
+  return nullptr;
+}
+
 // Helper class for managing global AudioManager data and hang monitor. If the
 // audio thread is hung for > |kMaxFailedPingsCount| * |max_hung_task_time_|, we
 // want to record a UMA and optionally a non-crash dump to find offenders in the
 // field.
 class AudioManagerHelper : public base::PowerObserver {
  public:
   // These values are histogrammed over time; do not change their ordinal
   // values.
   enum ThreadStatus {
     THREAD_NONE = 0,
@@ skipping 236 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(&CreateAudioFileWriterDummy));
 }
 
 // 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