Start and stop RTC event logs from private extension API.

chrome/common/extensions/api/webrtc_logging_private.idl

Index: chrome/common/extensions/api/webrtc_logging_private.idl
diff --git a/chrome/common/extensions/api/webrtc_logging_private.idl b/chrome/common/extensions/api/webrtc_logging_private.idl
index 0f900f944402da663da9706a1914fad707cc5bfa..bd2f0c4014df5c096f227dc23b113e51796a92db 100644
--- a/chrome/common/extensions/api/webrtc_logging_private.idl
+++ b/chrome/common/extensions/api/webrtc_logging_private.idl
@@ -28,23 +28,24 @@ namespace webrtcLoggingPrivate {
     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 {
@@ -139,13 +140,33 @@ namespace webrtcLoggingPrivate {
     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);
   };
 };