Implement writing mic audio input data to file for debugging purposes.

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 193 matching lines @@
 
 #if defined(ENABLE_WEBRTC)
 #include "content/browser/media/webrtc_internals.h"
 #include "content/browser/renderer_host/media/media_stream_track_metrics_host.h"
 #include "content/browser/renderer_host/media/webrtc_identity_service_host.h"
 #include "content/browser/renderer_host/p2p/socket_dispatcher_host.h"
 #include "content/common/media/aec_dump_messages.h"
 #include "content/common/media/media_stream_messages.h"
 #endif
 
+#if defined(OS_WIN)
+#define IntToStringType base::IntToString16
+#else
+#define IntToStringType base::IntToString
+#endif
+
 extern bool g_exited_main_message_loop;
 
 namespace content {
 namespace {
 
 const char kSiteProcessMapKeyName[] = "content_site_process_map";
 
+const char kAecDumpFileNameAddition[] = "aec_dump";
+
 void CacheShaderInfo(int32 id, base::FilePath path) {
   ShaderCacheFactory::GetInstance()->SetCacheInfo(id, path);
 }
 
 void RemoveShaderInfo(int32 id) {
   ShaderCacheFactory::GetInstance()->RemoveCacheInfo(id);
 }
 
 net::URLRequestContext* GetRequestContext(
     scoped_refptr<net::URLRequestContextGetter> request_context,
@@ skipping 553 matching lines @@
       storage_partition_impl_->GetAppCacheService(),
       ChromeBlobStorageContext::GetFor(browser_context),
       storage_partition_impl_->GetFileSystemContext(),
       storage_partition_impl_->GetServiceWorkerContext(),
       storage_partition_impl_->GetHostZoomLevelContext(),
       get_contexts_callback);
 
   AddFilter(resource_message_filter);
   MediaStreamManager* media_stream_manager =
       BrowserMainLoop::GetInstance()->media_stream_manager();
-  AddFilter(new AudioInputRendererHost(
+  // The AudioInputRendererHost and AudioRendererHost needs to be available for
+  // lookup, so it's stashed in a member variable.
+  audio_input_renderer_host_ = new AudioInputRendererHost(
       GetID(),
+      this,
       audio_manager,
       media_stream_manager,
       AudioMirroringManager::GetInstance(),
-      BrowserMainLoop::GetInstance()->user_input_monitor()));
-  // The AudioRendererHost needs to be available for lookup, so it's
-  // stashed in a member variable.
+      BrowserMainLoop::GetInstance()->user_input_monitor());
+  AddFilter(audio_input_renderer_host_.get());
   audio_renderer_host_ = new AudioRendererHost(
       GetID(),
       audio_manager,
       AudioMirroringManager::GetInstance(),
       media_internals,
       media_stream_manager,
       browser_context->GetResourceContext()->GetMediaDeviceIDSalt());
   AddFilter(audio_renderer_host_.get());
   AddFilter(
       new MidiHost(GetID(), BrowserMainLoop::GetInstance()->midi_manager()));
@@ skipping 940 matching lines @@
 
 void RenderProcessHostImpl::ResumeRequestsForView(int route_id) {
   widget_helper_->ResumeRequestsForView(route_id);
 }
 
 void RenderProcessHostImpl::FilterURL(bool empty_allowed, GURL* url) {
   FilterURL(this, empty_allowed, url);
 }
 
 #if defined(ENABLE_WEBRTC)
-void RenderProcessHostImpl::EnableAecDump(const base::FilePath& file) {
+void RenderProcessHostImpl::EnableAudioDebugRecordings(
+    const base::FilePath& file) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   // Enable AEC dump for each registered consumer.
+  base::FilePath file_with_extensions = GetAecDumpFilePathWithExtensions(file);
   for (std::vector<int>::iterator it = aec_dump_consumers_.begin();
        it != aec_dump_consumers_.end(); ++it) {
-    EnableAecDumpForId(file, *it);
+    EnableAecDumpForId(file_with_extensions, *it);
   }
+
+  // Enable mic input recording.
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&AudioInputRendererHost::EnableDebugRecording,
+                 audio_input_renderer_host_,

[nasko, 2015/08/19 22:04:15]

How do we guarantee that audio_input_renderer_host_ is not destroyed before the
IO thread gets to execute this task?

[Henrik Grunell, 2015/08/20 07:26:19]

AudioInputRendererHost is reference counted. Added comment about that.

+                 file));
 }
 
-void RenderProcessHostImpl::DisableAecDump() {
+void RenderProcessHostImpl::DisableAudioDebugRecordings() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   // Posting on the FILE thread and then replying back on the UI thread is only
   // for avoiding races between enable and disable. Nothing is done on the FILE
   // thread.
   BrowserThread::PostTaskAndReply(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DisableAecDumpOnFileThread),
       base::Bind(&RenderProcessHostImpl::SendDisableAecDumpToRenderer,
                  weak_factory_.GetWeakPtr()));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &AudioInputRendererHost::DisableDebugRecording,
+          audio_input_renderer_host_));

[nasko, 2015/08/19 22:04:15]

Same as above, it isn't clear how we guarantee lifetime and safety here.

[Henrik Grunell, 2015/08/20 07:26:19]

Ditto.

 }
 
 void RenderProcessHostImpl::SetWebRtcLogMessageCallback(
     base::Callback<void(const std::string&)> callback) {
   webrtc_log_message_callback_ = callback;
 }
 
 RenderProcessHostImpl::WebRtcStopRtpDumpCallback
 RenderProcessHostImpl::StartRtpDump(
     bool incoming,
@@ skipping 583 matching lines @@
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 
 #if defined(ENABLE_WEBRTC)
   // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/465841
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile7(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "465841 RenderProcessHostImpl::OnProcessLaunched::EnableAec"));
-  if (WebRTCInternals::GetInstance()->aec_dump_enabled())
-    EnableAecDump(WebRTCInternals::GetInstance()->aec_dump_file_path());
+  if (WebRTCInternals::GetInstance()->IsAudioDebugRecordingsEnabled()) {
+    EnableAudioDebugRecordings(
+        WebRTCInternals::GetInstance()->GetAudioDebugRecordingsFilePath());
+  }
 #endif
 }
 
 void RenderProcessHostImpl::OnProcessLaunchFailed() {
   // If this object will be destructed soon, then observers have already been
   // sent a RenderProcessHostDestroyed notification, and we must observe our
   // contract that says that will be the last call.
   if (deleting_soon_)
     return;
 
@@ skipping 58 matching lines @@
       FROM_HERE,
       base::Bind(
           &RenderProcessHostImpl::UnregisterAecDumpConsumerOnUIThread,
           weak_factory_.GetWeakPtr(),
           id));
 }
 
 void RenderProcessHostImpl::RegisterAecDumpConsumerOnUIThread(int id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   aec_dump_consumers_.push_back(id);
-  if (WebRTCInternals::GetInstance()->aec_dump_enabled()) {
-    EnableAecDumpForId(WebRTCInternals::GetInstance()->aec_dump_file_path(),
-                       id);
+  if (WebRTCInternals::GetInstance()->IsAudioDebugRecordingsEnabled()) {
+    EnableAecDumpForId(
+        GetAecDumpFilePathWithExtensions(
+            WebRTCInternals::GetInstance()->GetAudioDebugRecordingsFilePath()),
+        id);
   }
 }
 
 void RenderProcessHostImpl::UnregisterAecDumpConsumerOnUIThread(int id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (std::vector<int>::iterator it = aec_dump_consumers_.begin();
        it != aec_dump_consumers_.end(); ++it) {
     if (*it == id) {
       aec_dump_consumers_.erase(it);
       break;
     }
   }
 }
 
-#if defined(OS_WIN)
-#define IntToStringType base::IntToString16
-#else
-#define IntToStringType base::IntToString
-#endif
-
 void RenderProcessHostImpl::EnableAecDumpForId(const base::FilePath& file,
                                                int id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  base::FilePath unique_file =
-      file.AddExtension(IntToStringType(base::GetProcId(GetHandle())))
-          .AddExtension(IntToStringType(id));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CreateAecDumpFileForProcess, unique_file, GetHandle()),
+      base::Bind(&CreateAecDumpFileForProcess,
+                 file.AddExtension(IntToStringType(id)),
+                 GetHandle()),
       base::Bind(&RenderProcessHostImpl::SendAecDumpFileToRenderer,
                  weak_factory_.GetWeakPtr(),
                  id));
 }
 
-#undef IntToStringType
-
 void RenderProcessHostImpl::SendAecDumpFileToRenderer(
     int id,
     IPC::PlatformFileForTransit file_for_transit) {
   if (file_for_transit == IPC::InvalidPlatformFileForTransit())
     return;
   Send(new AecDumpMsg_EnableAecDump(id, file_for_transit));
 }
 
 void RenderProcessHostImpl::SendDisableAecDumpToRenderer() {
   Send(new AecDumpMsg_DisableAecDump());
 }
+
+base::FilePath RenderProcessHostImpl::GetAecDumpFilePathWithExtensions(
+    const base::FilePath& file) {
+  return file.AddExtension(kAecDumpFileNameAddition)
+             .AddExtension(IntToStringType(base::GetProcId(GetHandle())));
+}
 #endif
 
 void RenderProcessHostImpl::IncrementWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ++worker_ref_count_;
   if (worker_ref_count_ > max_worker_count_)
     max_worker_count_ = worker_ref_count_;
 }
 
 void RenderProcessHostImpl::DecrementWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_GT(worker_ref_count_, 0);
   --worker_ref_count_;
   if (worker_ref_count_ == 0)
     Cleanup();
 }
 
 void RenderProcessHostImpl::GetAudioOutputControllers(
     const GetAudioOutputControllersCallback& callback) const {
   audio_renderer_host()->GetOutputControllers(callback);
 }
 
 BluetoothDispatcherHost* RenderProcessHostImpl::GetBluetoothDispatcherHost() {
   return bluetooth_dispatcher_host_.get();
 }
 
 }  // namespace content