Move the call to enable the WebRTC event log from PeerConnectionFactory to PeerConnection.

content/browser/media/webrtc/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/webrtc_internals.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/media/webrtc/webrtc_internals_ui_observer.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/power_save_blocker.h"
-#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
+#include "ipc/ipc_platform_file.h"
+
+#if defined(OS_WIN)
+#define IntToStringType base::IntToString16
+#else
+#define IntToStringType base::IntToString
+#endif
 
 using base::ProcessId;
 using std::string;
 
 namespace content {
 
 namespace {
 
 static base::LazyInstance<WebRTCInternals>::Leaky g_webrtc_internals =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 217 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 audio debug recordings if it is enabled and the last
+  // Disables event log and audio debug recordings if enabled and the last
   // webrtc-internals page is going away.
-  if (audio_debug_recordings_ && !observers_.might_have_observers())
-    DisableAudioDebugRecordings();
+  if (!observers_.might_have_observers()) {
+    if (audio_debug_recordings_)
+      DisableAudioDebugRecordings();
+    DisableEventLogRecordings();
+  }
 }
 
 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) {
@@ skipping 44 matching lines @@
 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::SetEventLogRecordings(
-    bool enable,
+void WebRTCInternals::EnableEventLogRecordings(
     content::WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(ENABLE_WEBRTC)
-  if (enable) {
 #if defined(OS_ANDROID)
-    EnableEventLogRecordingsOnAllRenderProcessHosts();
+  EnableEventLogRecordingsOnAllRenderProcessHosts();
 #else
-    DCHECK(web_contents);
-    DCHECK(select_file_dialog_ == nullptr);
-    selecting_event_log_ = true;
-    select_file_dialog_ = ui::SelectFileDialog::Create(this, nullptr);
-    select_file_dialog_->SelectFile(
-        ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(),
-        event_log_recordings_file_path_, nullptr, 0, FILE_PATH_LITERAL(""),
-        web_contents->GetTopLevelNativeWindow(), nullptr);
+  DCHECK(web_contents);
+  DCHECK(select_file_dialog_ == nullptr);
+  selecting_event_log_ = true;
+  select_file_dialog_ = ui::SelectFileDialog::Create(this, nullptr);
+  select_file_dialog_->SelectFile(
+      ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(),
+      event_log_recordings_file_path_, nullptr, 0, FILE_PATH_LITERAL(""),
+      web_contents->GetTopLevelNativeWindow(), nullptr);
 #endif
-  } else {
-    event_log_recordings_ = false;
-    // Tear down the dialog since the user has unchecked the audio debug
-    // recordings box.
-    select_file_dialog_ = nullptr;
-    DCHECK(select_file_dialog_->HasOneRef());
-
-    for (RenderProcessHost::iterator i(
-             content::RenderProcessHost::AllHostsIterator());
-         !i.IsAtEnd(); i.Advance()) {
-      i.GetCurrentValue()->DisableEventLogRecordings();
-    }
-  }
 #endif
 }
 
+void WebRTCInternals::DisableEventLogRecordings() {
+#if defined(ENABLE_WEBRTC)
+  event_log_recordings_ = false;
+  // Tear down the dialog since the user has unchecked the event log checkbox.

[Henrik Grunell, 2016/06/03 07:40:53]

Nit: Is the DCHECK for one ref not useful anymore?

[Ivo-OOO until feb 6, 2016/06/03 16:07:02]

The DCHECK is problematic because the file dialog is shared with the AEC dump
checkbox,  it can be set to nullptr in the DisableAudioDebugRecordings()
function.

[Henrik Grunell, 2016/06/08 10:08:50]

Acknowledged.

+  select_file_dialog_ = nullptr;
+  for (RenderProcessHost::iterator i(
+           content::RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance())
+    i.GetCurrentValue()->StopWebRTCEventLog();
+#endif
+}
+
 bool WebRTCInternals::IsEventLogRecordingsEnabled() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return event_log_recordings_;
 }
 
-const base::FilePath& WebRTCInternals::GetEventLogRecordingsFilePath() const {
+const base::FilePath& WebRTCInternals::GetEventLogFilePath() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return event_log_recordings_file_path_;
 }
 
 void WebRTCInternals::SendUpdate(const string& command,
                                  std::unique_ptr<base::Value> value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(observers_.might_have_observers());
 
   bool queue_was_empty = pending_updates_.empty();
@@ skipping 105 matching lines @@
         audio_debug_recordings_file_path_);
   }
 }
 
 void WebRTCInternals::EnableEventLogRecordingsOnAllRenderProcessHosts() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   event_log_recordings_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->EnableEventLogRecordings(
-        event_log_recordings_file_path_);
-  }
+       !i.IsAtEnd(); i.Advance())
+    i.GetCurrentValue()->StartWebRTCEventLog(event_log_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();
@@ skipping 11 matching lines @@
   while (!pending_updates_.empty()) {
     const auto& update = pending_updates_.front();
     FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
                       observers_,
                       OnUpdate(update.command(), update.value()));
     pending_updates_.pop();
   }
 }
 
 }  // namespace content