Audio output debug recording.

chrome/browser/media/webrtc/audio_debug_recordings_handler.cc

 // Copyright 2016 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 "chrome/browser/media/audio_debug_recordings_handler.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/media/webrtc/webrtc_log_list.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
+#include "media/audio/audio_manager.h"
 
 using content::BrowserThread;
 
 // Keys used to attach handler to the RenderProcessHost
 const char AudioDebugRecordingsHandler::kAudioDebugRecordingsHandlerKey[] =
     "kAudioDebugRecordingsHandlerKey";
 
 namespace {
 
 // Returns a path name to be used as prefix for audio debug recordings files.
@@ skipping 69 matching lines @@
   if (is_audio_debug_recordings_in_progress_) {
     error_callback.Run("Audio debug recordings already in progress");
     return;
   }
 
   is_audio_debug_recordings_in_progress_ = true;
   base::FilePath prefix_path = GetAudioDebugRecordingsPrefixPath(
       log_directory, ++current_audio_debug_recordings_id_);
   host->EnableAudioDebugRecordings(prefix_path);
 
+  // AudioManager is deleted on the audio thread, and the AudioManager outlives
+  // this object, so it's safe to post unretained.

[o1ka, 2017/01/31 11:00:11]

Add why media::AudioManager::Get() is safe (or better use a pointer instead)?

[Henrik Grunell, 2017/02/08 11:29:37]

Changed to a pointer injected.

+  media::AudioManager* audio_manager = media::AudioManager::Get();

[Max Morin, 2017/01/30 10:24:01]

The AudioManager::Get() pointer is nulled on the UI thread, before the
AudioManager is actually deleted. Are you sure you can't get null here? (The
lifetime of this object isn't obvious to me).

[Henrik Grunell, 2017/01/30 14:11:26]

I'll double check that tomorrow.

[Henrik Grunell, 2017/02/08 11:29:37]

This class lives on the UI thread, which is implicit. See the PostDelayedTask
below - it posts on the UI thread to run DoStopAudioDebugRecordings(), which
uses the class wide thread checker. I've changed to check the UI thread
explicitly in all functions instead which makes that clearer.

After doing that, I also changed to inject a pointer instead based on Olga's
comment above.

+  audio_manager->GetTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&media::AudioManager::EnableOutputDebugRecording,
+                            base::Unretained(audio_manager), prefix_path));
+
   if (delay.is_zero()) {
     const bool is_stopped = false, is_manual_stop = false;
     callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
     return;
   }
 
   const bool is_manual_stop = false;
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&AudioDebugRecordingsHandler::DoStopAudioDebugRecordings, this,
@@ skipping 23 matching lines @@
     const bool is_stopped = false;
     callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
     return;
   }
 
   if (!is_audio_debug_recordings_in_progress_) {
     error_callback.Run("No audio debug recording in progress");
     return;
   }
 
+  // AudioManager is deleted on the audio thread, and the AudioManager outlives
+  // this object, so it's safe to post unretained.
+  media::AudioManager* audio_manager = media::AudioManager::Get();
+  audio_manager->GetTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&media::AudioManager::DisableOutputDebugRecording,
+                            base::Unretained(audio_manager)));
+
   host->DisableAudioDebugRecordings();
+
   is_audio_debug_recordings_in_progress_ = false;
   const bool is_stopped = true;
   callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
 }