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

content/browser/media/webrtc_internals.cc

 // Copyright (c) 2013 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 "content/browser/media/webrtc_internals.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/media/webrtc_internals_ui_observer.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 19 matching lines @@
     log = new base::ListValue();
     if (log)
       dict->Set("log", log);
   }
   return log;
 }
 
 }  // namespace
 
 WebRTCInternals::WebRTCInternals()
-    : aec_dump_enabled_(false) {
+    : audio_debug_recordings_(false) {
 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
 // build if WebRTC is disabled?
 #if defined(ENABLE_WEBRTC)
-  aec_dump_file_path_ =
+  audio_debug_recordings_file_path_ =
       GetContentClient()->browser()->GetDefaultDownloadDirectory();
-  if (aec_dump_file_path_.empty()) {
-    // In this case the default path (|aec_dump_file_path_|) will be empty and
-    // the platform default path will be used in the file dialog (with no
-    // default file name). See SelectFileDialog::SelectFile. On Android where
-    // there's no dialog we'll fail to open the file.
+  if (audio_debug_recordings_file_path_.empty()) {
+    // In this case the default path (|audio_debug_recordings_file_path_|) will
+    // be empty and the platform default path will be used in the file dialog
+    // (with no default file name). See SelectFileDialog::SelectFile. On Android
+    // where there's no dialog we'll fail to open the file.
     VLOG(1) << "Could not get the download directory.";
   } else {
-    aec_dump_file_path_ =
-        aec_dump_file_path_.Append(FILE_PATH_LITERAL("audio.aecdump"));
+    audio_debug_recordings_file_path_ =
+        audio_debug_recordings_file_path_.Append(
+            FILE_PATH_LITERAL("audio_debug"));
   }
 #endif  // defined(ENABLE_WEBRTC)
 }
 
 WebRTCInternals::~WebRTCInternals() {
 }
 
 WebRTCInternals* WebRTCInternals::GetInstance() {
   return g_webrtc_internals.Pointer();
 }
@@ skipping 149 matching lines @@
 
 void WebRTCInternals::AddObserver(WebRTCInternalsUIObserver *observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
 void WebRTCInternals::RemoveObserver(WebRTCInternalsUIObserver *observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 
-  // Disables the AEC recording if it is enabled and the last webrtc-internals
-  // page is going away.
-  if (aec_dump_enabled_ && !observers_.might_have_observers())
-    DisableAecDump();
+  // Disables audio debug recordings if it is enabled and the last
+  // webrtc-internals page is going away.
+  if (audio_debug_recordings_ && !observers_.might_have_observers())
+    DisableAudioDebugRecordings();
 }
 
 void WebRTCInternals::UpdateObserver(WebRTCInternalsUIObserver* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (peer_connection_data_.GetSize() > 0)
     observer->OnUpdate("updateAllPeerConnections", &peer_connection_data_);
 
   for (base::ListValue::iterator it = get_user_media_requests_.begin();
        it != get_user_media_requests_.end();
        ++it) {
     observer->OnUpdate("addGetUserMedia", *it);
   }
 }
 
-void WebRTCInternals::EnableAecDump(content::WebContents* web_contents) {
+void WebRTCInternals::EnableAudioDebugRecordings(
+    content::WebContents* web_contents) {
 #if defined(ENABLE_WEBRTC)
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(OS_ANDROID)
-  EnableAecDumpOnAllRenderProcessHosts();
+  EnableAudioDebugRecordingsOnAllRenderProcessHosts();
 #else
   select_file_dialog_ = ui::SelectFileDialog::Create(this, NULL);
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE,
       base::string16(),
-      aec_dump_file_path_,
+      audio_debug_recordings_file_path_,
       NULL,
       0,
       FILE_PATH_LITERAL(""),
       web_contents->GetTopLevelNativeWindow(),
       NULL);
 #endif
 #endif
 }
 
-void WebRTCInternals::DisableAecDump() {
+void WebRTCInternals::DisableAudioDebugRecordings() {
 #if defined(ENABLE_WEBRTC)
-  aec_dump_enabled_ = false;
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  audio_debug_recordings_ = false;
 
-  // Tear down the dialog since the user has unchecked the AEC dump box.
+  // Tear down the dialog since the user has unchecked the audio debug
+  // recordings box.
   select_file_dialog_ = NULL;
 
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->DisableAecDump();
+    i.GetCurrentValue()->DisableAudioDebugRecordings();
   }
 #endif
 }
 
+bool WebRTCInternals::IsAudioDebugRecordingsEnabled() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return audio_debug_recordings_;
+}
+
+const base::FilePath& WebRTCInternals::GetAudioDebugRecordingsFilePath() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return audio_debug_recordings_file_path_;
+}
+
 void WebRTCInternals::ResetForTesting() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.Clear();
   peer_connection_data_.Clear();
   CreateOrReleasePowerSaveBlocker();
   get_user_media_requests_.Clear();
-  aec_dump_enabled_ = false;
+  audio_debug_recordings_ = false;
 }
 
 void WebRTCInternals::SendUpdate(const string& command, base::Value* value) {
   DCHECK(observers_.might_have_observers());
 
   FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
                     observers_,
                     OnUpdate(command, value));
 }
 
 void WebRTCInternals::RenderProcessHostDestroyed(RenderProcessHost* host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OnRendererExit(host->GetID());
 
   render_process_id_set_.erase(host->GetID());
   host->RemoveObserver(this);
 }
 
 void WebRTCInternals::FileSelected(const base::FilePath& path,
                                    int /* unused_index */,
                                    void* /*unused_params */) {
 #if defined(ENABLE_WEBRTC)
-  aec_dump_file_path_ = path;
-  EnableAecDumpOnAllRenderProcessHosts();
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  audio_debug_recordings_file_path_ = path;
+  EnableAudioDebugRecordingsOnAllRenderProcessHosts();
 #endif
 }
 
 void WebRTCInternals::FileSelectionCanceled(void* params) {
 #if defined(ENABLE_WEBRTC)
-  SendUpdate("aecRecordingFileSelectionCancelled", NULL);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  SendUpdate("audioDebugRecordingsFileSelectionCancelled", NULL);
 #endif
 }
 
 void WebRTCInternals::OnRendererExit(int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Iterates from the end of the list to remove the PeerConnections created
   // by the exitting renderer.
   for (int i = peer_connection_data_.GetSize() - 1; i >= 0; --i) {
     base::DictionaryValue* record = NULL;
@@ skipping 35 matching lines @@
   }
 
   if (found_any && observers_.might_have_observers()) {
     base::DictionaryValue update;
     update.SetInteger("rid", render_process_id);
     SendUpdate("removeGetUserMediaForRenderer", &update);
   }
 }
 
 #if defined(ENABLE_WEBRTC)
-void WebRTCInternals::EnableAecDumpOnAllRenderProcessHosts() {
-  aec_dump_enabled_ = true;
+void WebRTCInternals::EnableAudioDebugRecordingsOnAllRenderProcessHosts() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  audio_debug_recordings_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->EnableAecDump(aec_dump_file_path_);
+    i.GetCurrentValue()->EnableAudioDebugRecordings(
+        audio_debug_recordings_file_path_);
   }
 }
 #endif
 
 void WebRTCInternals::CreateOrReleasePowerSaveBlocker() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (peer_connection_data_.empty() && power_save_blocker_) {
     DVLOG(1) << ("Releasing the block on application suspension since no "
                  "PeerConnections are active anymore.");
     power_save_blocker_.reset();
   } else if (!peer_connection_data_.empty() && !power_save_blocker_) {
     DVLOG(1) << ("Preventing the application from being suspended while one or "
                  "more PeerConnections are active.");
     power_save_blocker_ =
         content::PowerSaveBlocker::Create(
             PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
             PowerSaveBlocker::kReasonOther,
             "WebRTC has active PeerConnections").Pass();
   }
 }
 
 }  // namespace content