Start and stop RTC event logs from private extension API.

chrome/common/extensions/api/webrtc_logging_private.idl

 // 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.
 
 // Use the <code>chrome.webrtcLoggingPrivate</code> API to control diagnostic
 // WebRTC logging.
 namespace webrtcLoggingPrivate {
   dictionary MetaDataEntry {
     // The meta data entry key.
     DOMString key;
@@ skipping 10 matching lines @@
   dictionary RequestInfo {
     // The tab identifier from the chrome.tabs API, if the request is from a
     // tab.
     long? tabId;
 
     // The guest process id for the requester, if the request is from a
     // webview.
     long? guestProcessId;
   };
 
-  // This contains information about the result of audio debug recordings.
-  dictionary AudioDebugRecordingsInfo {
+  // This contains information about the result of audio debug recordings or
+  // RTC event logs.
+  dictionary TimeLimitedRecordingInfo {

[Henrik Grunell, 2016/02/01 13:58:13]

The recordings don't have to be time limited (|seconds| == 0), so the naming is
a bit confusing. Maybe just skip "TimeLimited"?

[terelius1, 2016/02/16 20:09:12]

Since the main difference between this callback and e.g. GenericDoneCallback is
that the new callback can fire   after a certain time limit (in addition to a
manual stop), I thought it was an appropriate name. I am open to suggestions.

[Henrik Grunell, 2016/02/23 15:29:10]

The main difference is that the generic callback don't have any arguments, while
the recording callback does, and it contains recording info. Drop "TimeLimited",
it's enough to know that it can be time limited in the function call. We also
don't make any difference between time limited and unlimited info and callback.

     // Absolute path prefix for the files with the audio debug recordings.
     DOMString prefixPath;
 
-    // Indicates if recording was stopped.
+    // Indicates if recording was stopped (either by a timed callback after the
+    // time limit has elapsed, or by a manual call).
     boolean didStop;
 
     // Indicates if recording was stopped manually through a
-    // stopAudioDebugRecordings() call.
+    // stopAudioDebugRecordings() or stopRtcEventLogging() call.
     boolean didManualStop;
   };
 
-
   callback GenericDoneCallback = void ();
-  callback AudioDebugRecordingsCallback =
-      void (AudioDebugRecordingsInfo info);
+  callback TimeLimitedRecordingCallback =
+      void (TimeLimitedRecordingInfo info);
   callback UploadDoneCallback = void (UploadResult result);
 
   interface Functions {
     // For all functions, |request| determines which render process to apply
     // the operation on. |request| identifies the requesting process.
     // |securityOrigin| is the security origin for the tab identified by |tabId|
     // and is used for verifying that the tab is the correct one and has not
     // been navigated away from.
 
     // Sets additional custom meta data that will be uploaded along with the
@@ skipping 74 matching lines @@
     // |seconds| indicates how many seconds of audio to record. |callback|
     // is invoked once recording stops.
     // If |seconds| is zero, recording will continue until
     // stopAudioDebugRecordings() is explicitly called. In this case,
     // |callback| is invoked once recording starts and will report
     // that recording has not stopped.
     // If |seconds| is negative, startAudioDebugRecordings() fails.
     static void startAudioDebugRecordings(RequestInfo request,
                              DOMString securityOrigin,
                              long seconds,
-                             AudioDebugRecordingsCallback callback);
+                             TimeLimitedRecordingCallback callback);
 
     // Stops audio debug recordings.  |callback| is invoked once recording
     // stops. If there is no recording in progress, stopAudioDebugRecordings()
     // fails.
     static void stopAudioDebugRecordings(RequestInfo request,
                             DOMString securityOrigin,
-                            AudioDebugRecordingsCallback callback);
+                            TimeLimitedRecordingCallback callback);
+
+    // Starts RTC event logging.
+    // startRtcEventLogging() logs the most recent events that happened before
+    // the call, and then keep logging for |seconds| seconds into the future.
+    // |callback| is invoked once the logging stops.
+    // If |seconds| is zero, the logging will continue until
+    // stopRtcEventLogging() is explicitly called. In this case,
+    // |callback| is invoked once recording starts and will report
+    // that recording has not stopped.
+    // If |seconds| is negative, startRtcEventLogging() fails.
+    static void startRtcEventLogging(RequestInfo request,
+                             DOMString securityOrigin,
+                             long seconds,
+                             TimeLimitedRecordingCallback callback);
+
+    // Stops RTC event logging. |callback| is invoked once the logging stops.
+    // If there is no recording in progress, stopRtcEventLogging() fails.
+    static void stopRtcEventLogging(RequestInfo request,
+                            DOMString securityOrigin,
+                            TimeLimitedRecordingCallback callback);
   };
 };