Start and stop RTC event logs from private extension API.

chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc

 // Copyright 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 "chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h"
 
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 24 matching lines @@
 namespace StartRtpDump = api::webrtc_logging_private::StartRtpDump;
 namespace Stop = api::webrtc_logging_private::Stop;
 namespace StopRtpDump = api::webrtc_logging_private::StopRtpDump;
 namespace Store = api::webrtc_logging_private::Store;
 namespace Upload = api::webrtc_logging_private::Upload;
 namespace UploadStored = api::webrtc_logging_private::UploadStored;
 namespace StartAudioDebugRecordings =
     api::webrtc_logging_private::StartAudioDebugRecordings;
 namespace StopAudioDebugRecordings =
     api::webrtc_logging_private::StopAudioDebugRecordings;
+namespace StartWebRtcEventLogging =
+    api::webrtc_logging_private::StartWebRtcEventLogging;
+namespace StopWebRtcEventLogging =
+    api::webrtc_logging_private::StopWebRtcEventLogging;
 
 namespace {
 std::string HashIdWithOrigin(const std::string& security_origin,
                              const std::string& log_id) {
   return base::UintToString(base::Hash(security_origin + log_id));
 }
 }  // namespace
 
 content::RenderProcessHost* WebrtcLoggingPrivateFunction::RphFromRequest(
     const RequestInfo& request, const std::string& security_origin) {
@@ skipping 34 matching lines @@
 }
 
 scoped_refptr<WebRtcLoggingHandlerHost>
 WebrtcLoggingPrivateFunction::LoggingHandlerFromRequest(
     const api::webrtc_logging_private::RequestInfo& request,
     const std::string& security_origin) {
   content::RenderProcessHost* host = RphFromRequest(request, security_origin);
   if (!host)
     return nullptr;
 
-  return base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host);
+  return base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(
+      host, WebRtcLoggingHandlerHost::kWebRtcLoggingHandlerHostKey);
 }
 
 scoped_refptr<WebRtcLoggingHandlerHost>
 WebrtcLoggingPrivateFunctionWithGenericCallback::PrepareTask(
     const RequestInfo& request, const std::string& security_origin,
     WebRtcLoggingHandlerHost::GenericDoneCallback* callback) {
   *callback = base::Bind(
       &WebrtcLoggingPrivateFunctionWithGenericCallback::FireCallback, this);
   return LoggingHandlerFromRequest(request, security_origin);
 }
@@ skipping 13 matching lines @@
   if (success) {
     api::webrtc_logging_private::UploadResult result;
     result.report_id = report_id;
     SetResult(result.ToValue().release());
   } else {
     SetError(error_message);
   }
   SendResponse(success);
 }
 
-void WebrtcLoggingPrivateFunctionWithAudioDebugRecordingsCallback::
-    FireErrorCallback(const std::string& error_message) {
+void WebrtcLoggingPrivateFunctionWithRecordingDoneCallback::FireErrorCallback(
+    const std::string& error_message) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   SetError(error_message);
   SendResponse(false);
 }
 
-void WebrtcLoggingPrivateFunctionWithAudioDebugRecordingsCallback::FireCallback(
+void WebrtcLoggingPrivateFunctionWithRecordingDoneCallback::FireCallback(
     const std::string& prefix_path,
     bool did_stop,
     bool did_manual_stop) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  api::webrtc_logging_private::AudioDebugRecordingsInfo result;
+  api::webrtc_logging_private::RecordingInfo result;
   result.prefix_path = prefix_path;
   result.did_stop = did_stop;
   result.did_manual_stop = did_manual_stop;
   SetResult(result.ToValue().release());
   SendResponse(true);
 }
 
 bool WebrtcLoggingPrivateSetMetaDataFunction::RunAsync() {
   std::unique_ptr<SetMetaData::Params> params(
       SetMetaData::Params::Create(*args_));
@@ skipping 158 matching lines @@
       (params->incoming && params->outgoing)
           ? RTP_DUMP_BOTH
           : (params->incoming ? RTP_DUMP_INCOMING : RTP_DUMP_OUTGOING);
 
   content::RenderProcessHost* host =
       RphFromRequest(params->request, params->security_origin);
   if (!host)
     return false;
 
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
-      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(
+          host, WebRtcLoggingHandlerHost::kWebRtcLoggingHandlerHostKey));
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateStartRtpDumpFunction::FireCallback, this);
 
   // This call cannot fail.
   content::RenderProcessHost::WebRtcStopRtpDumpCallback stop_callback =
       host->StartRtpDump(params->incoming,
                          params->outgoing,
                          base::Bind(&WebRtcLoggingHandlerHost::OnRtpPacket,
                                     webrtc_logging_handler_host));
@@ skipping 22 matching lines @@
       (params->incoming && params->outgoing)
           ? RTP_DUMP_BOTH
           : (params->incoming ? RTP_DUMP_INCOMING : RTP_DUMP_OUTGOING);
 
   content::RenderProcessHost* host =
       RphFromRequest(params->request, params->security_origin);
   if (!host)
     return false;
 
   scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
-      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(
+          host, WebRtcLoggingHandlerHost::kWebRtcLoggingHandlerHostKey));
 
   WebRtcLoggingHandlerHost::GenericDoneCallback callback = base::Bind(
       &WebrtcLoggingPrivateStopRtpDumpFunction::FireCallback, this);
 
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&WebRtcLoggingHandlerHost::StopRtpDump,
                                      webrtc_logging_handler_host,
                                      type,
                                      callback));
@@ skipping 13 matching lines @@
   if (params->seconds < 0) {
     FireErrorCallback("seconds must be greater than or equal to 0");
     return true;
   }
 
   content::RenderProcessHost* host =
       RphFromRequest(params->request, params->security_origin);
   if (!host)
     return false;
 
-  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
-      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+  scoped_refptr<AudioDebugRecordingsHandler> audio_debug_recordings_handler(
+      base::UserDataAdapter<AudioDebugRecordingsHandler>::Get(
+          host, AudioDebugRecordingsHandler::kAudioDebugRecordingsHandlerKey));
 
-  webrtc_logging_handler_host->StartAudioDebugRecordings(
+  audio_debug_recordings_handler->StartAudioDebugRecordings(
       host, base::TimeDelta::FromSeconds(params->seconds),
       base::Bind(
           &WebrtcLoggingPrivateStartAudioDebugRecordingsFunction::FireCallback,
           this),
       base::Bind(&WebrtcLoggingPrivateStartAudioDebugRecordingsFunction::
                      FireErrorCallback,
                  this));
   return true;
 }
 
 bool WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::RunAsync() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioDebugRecordingsFromExtension)) {
     return false;
   }
 
   std::unique_ptr<StopAudioDebugRecordings::Params> params(
       StopAudioDebugRecordings::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   content::RenderProcessHost* host =
       RphFromRequest(params->request, params->security_origin);
   if (!host)
     return false;
 
-  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
-      base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host));
+  scoped_refptr<AudioDebugRecordingsHandler> audio_debug_recordings_handler(
+      base::UserDataAdapter<AudioDebugRecordingsHandler>::Get(
+          host, AudioDebugRecordingsHandler::kAudioDebugRecordingsHandlerKey));
 
-  webrtc_logging_handler_host->StopAudioDebugRecordings(
+  audio_debug_recordings_handler->StopAudioDebugRecordings(
       host,
       base::Bind(
           &WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::FireCallback,
           this),
       base::Bind(&WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::
                      FireErrorCallback,
                  this));
   return true;
 }
 
+bool WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::RunAsync() {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableWebRtcEventLoggingFromExtension)) {
+    return false;
+  }
+
+  scoped_ptr<StartWebRtcEventLogging::Params> params(
+      StartWebRtcEventLogging::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  if (params->seconds < 0) {
+    FireErrorCallback("seconds must be greater than or equal to 0");
+    return true;
+  }
+
+  content::RenderProcessHost* host =
+      RphFromRequest(params->request, params->security_origin);
+  if (!host)
+    return false;
+
+  scoped_refptr<WebRtcEventLogHandler> webrtc_event_log_handler(
+      base::UserDataAdapter<WebRtcEventLogHandler>::Get(
+          host, WebRtcEventLogHandler::kWebRtcEventLogHandlerKey));
+
+  webrtc_event_log_handler->StartWebRtcEventLogging(
+      host, base::TimeDelta::FromSeconds(params->seconds),
+      base::Bind(
+        &WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::FireCallback,
+        this),
+      base::Bind(
+        &WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::FireErrorCallback,
+        this));
+  return true;
+}
+
+bool WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::RunAsync() {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableWebRtcEventLoggingFromExtension)) {
+    return false;
+  }
+
+  scoped_ptr<StopWebRtcEventLogging::Params> params(
+      StopWebRtcEventLogging::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  content::RenderProcessHost* host =
+      RphFromRequest(params->request, params->security_origin);
+  if (!host)
+    return false;
+
+  scoped_refptr<WebRtcEventLogHandler> webrtc_event_log_handler(
+      base::UserDataAdapter<WebRtcEventLogHandler>::Get(
+          host, WebRtcEventLogHandler::kWebRtcEventLogHandlerKey));
+
+  webrtc_event_log_handler->StopWebRtcEventLogging(
+      host,
+      base::Bind(
+        &WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::FireCallback,
+        this),
+      base::Bind(
+        &WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::FireErrorCallback,
+        this));
+  return true;
+}
+
 }  // namespace extensions