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/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;
 
 // Makes sure that |dict| has a ListValue under path "log".
 static base::ListValue* EnsureLogList(base::DictionaryValue* dict) {
   base::ListValue* log = NULL;
   if (!dict->GetList("log", &log)) {
     log = new base::ListValue();
     if (log)
       dict->Set("log", log);
   }
   return log;
 }
-

[Henrik Grunell, 2016/05/10 08:44:56]

Keep empty line.

[Ivo-OOO until feb 6, 2016/05/12 13:23:23]

Done.

 }  // namespace
 
 WebRTCInternals::PendingUpdate::PendingUpdate(
     const std::string& command,
     std::unique_ptr<base::Value> value)
     : command_(command), value_(std::move(value)) {}
 
 WebRTCInternals::PendingUpdate::PendingUpdate(PendingUpdate&& other)
     : command_(std::move(other.command_)),
       value_(std::move(other.value_)) {}
@@ skipping 11 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return value_.get();
 }
 
 WebRTCInternals::WebRTCInternals() : WebRTCInternals(500) {}
 
 WebRTCInternals::WebRTCInternals(int aggregate_updates_ms)
     : audio_debug_recordings_(false),
       event_log_recordings_(false),
       selecting_event_log_(false),
+      number_event_log_files_(0),
       aggregate_updates_ms_(aggregate_updates_ms),
       weak_factory_(this) {
 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
 // build if WebRTC is disabled?
 #if defined(ENABLE_WEBRTC)
   audio_debug_recordings_file_path_ =
       GetContentClient()->browser()->GetDefaultDownloadDirectory();
   event_log_recordings_file_path_ = audio_debug_recordings_file_path_;
 
   if (audio_debug_recordings_file_path_.empty()) {
@@ skipping 254 matching lines @@
     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.
+    DCHECK(select_file_dialog_->HasOneRef());
     select_file_dialog_ = nullptr;
-    DCHECK(select_file_dialog_->HasOneRef());
 
     for (RenderProcessHost::iterator i(
              content::RenderProcessHost::AllHostsIterator());
          !i.IsAtEnd(); i.Advance()) {
-      i.GetCurrentValue()->DisableEventLogRecordings();
+      int rid = i.GetCurrentValue()->GetID();

[Henrik Grunell, 2016/05/10 08:44:56]

I'd prefer to have some other component keep track of the event log handler.
Though it's not much code here, so it's not too bad.

Also, when the event log can be enabled through an extension API, it seems more
suitable to have it somewhere else. Is the plan to keep it here when that is
added or change?

[Ivo-OOO until feb 6, 2016/05/12 13:23:23]

I have moved this into a new class: WebRTCCallbackInterface.

+      if (event_log_handlers.count(rid)) {
+        event_log_handlers[rid].second.Run();
+      }
     }
   }
 #endif
 }
 
 bool WebRTCInternals::IsEventLogRecordingsEnabled() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return event_log_recordings_;
 }
 
-const base::FilePath& WebRTCInternals::GetEventLogRecordingsFilePath() const {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  return event_log_recordings_file_path_;
+void WebRTCInternals::RegisterEventLogHandler(
+    int render_process_id,
+    event_log_start_func start_logging_callback,
+    event_log_stop_func stop_logging_callback) {
+  event_log_handlers[render_process_id] =
+      std::make_pair(start_logging_callback, stop_logging_callback);
 }
 
 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();
   pending_updates_.push(PendingUpdate(command, std::move(value)));
 
@@ skipping 104 matching lines @@
   }
 }
 
 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_);
+    int rid = i.GetCurrentValue()->GetID();
+    if (event_log_handlers.count(rid)) {
+      event_log_handlers[rid].first.Run(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.");
@@ skipping 12 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