DevTools: add extension API to contribute trace events to timeline

third_party/WebKit/Source/devtools/front_end/timeline/TimelineController.js

 // Copyright 2016 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.
 
-/** @typedef {!{range: !Protocol.CSS.SourceRange, styleSheetId: !Protocol.CSS.StyleSheetId, wasUsed: boolean}} */
-SDK.CSSModel.RuleUsage;
-
 /**
  * @implements {SDK.TargetManager.Observer}
  * @implements {SDK.TracingManagerClient}
  * @unrestricted
  */
 Timeline.TimelineController = class {
   /**
    * @param {!SDK.Target} target
    * @param {!Timeline.TimelineLifecycleDelegate} delegate
    * @param {!SDK.TracingModel} tracingModel
    */
   constructor(target, delegate, tracingModel) {
     this._delegate = delegate;
     this._target = target;
     this._tracingModel = tracingModel;
     this._targets = [];
+    /** @type {!Array<!Timeline.ExtensionTracingSession>} */
+    this._extensionSessions = [];
     SDK.targetManager.observeTargets(this);
 
     if (Runtime.experiments.isEnabled('timelineRuleUsageRecording'))
       this._markUnusedCSS = Common.settings.createSetting('timelineMarkUnusedCSS', false);
   }
 
   /**
-   * @param {boolean} captureCauses
-   * @param {boolean} enableJSSampling
-   * @param {boolean} captureMemory
-   * @param {boolean} capturePictures
-   * @param {boolean} captureFilmStrip
+   * @param {!Timeline.TimelineController.CaptureOptions} options
+   * @param {!Array<!Extensions.ExtensionTraceProvider>} providers
    */
-  startRecording(captureCauses, enableJSSampling, captureMemory, capturePictures, captureFilmStrip) {
+  startRecording(options, providers) {
     this._extensionTraceProviders = Extensions.extensionServer.traceProviders().slice();
 
     function disabledByDefault(category) {
       return 'disabled-by-default-' + category;
     }
     var categoriesArray = [
       '-*', 'devtools.timeline', 'v8.execute', disabledByDefault('devtools.timeline'),
       disabledByDefault('devtools.timeline.frame'), SDK.TracingModel.TopLevelEventCategory,
       TimelineModel.TimelineModel.Category.Console, TimelineModel.TimelineModel.Category.UserTiming
     ];
     categoriesArray.push(TimelineModel.TimelineModel.Category.LatencyInfo);
 
-    if (Runtime.experiments.isEnabled('timelineV8RuntimeCallStats') && enableJSSampling)
+    if (Runtime.experiments.isEnabled('timelineV8RuntimeCallStats') && options.enableJSSampling)
       categoriesArray.push(disabledByDefault('v8.runtime_stats_sampling'));
-    if (Runtime.experiments.isEnabled('timelineTracingJSProfile') && enableJSSampling) {
+    if (Runtime.experiments.isEnabled('timelineTracingJSProfile') && options.enableJSSampling) {
       categoriesArray.push(disabledByDefault('v8.cpu_profiler'));
       if (Common.moduleSetting('highResolutionCpuProfiling').get())
         categoriesArray.push(disabledByDefault('v8.cpu_profiler.hires'));
     }
-    if (captureCauses || enableJSSampling)
+    if (options.captureCauses || options.enableJSSampling)
       categoriesArray.push(disabledByDefault('devtools.timeline.stack'));
-    if (captureCauses && Runtime.experiments.isEnabled('timelineInvalidationTracking'))
+    if (options.captureCauses && Runtime.experiments.isEnabled('timelineInvalidationTracking'))
       categoriesArray.push(disabledByDefault('devtools.timeline.invalidationTracking'));
-    if (capturePictures) {
+    if (options.capturePictures) {
       categoriesArray.push(
           disabledByDefault('devtools.timeline.layers'), disabledByDefault('devtools.timeline.picture'),
           disabledByDefault('blink.graphics_context_annotations'));
     }
-    if (captureFilmStrip)
+    if (options.captureFilmStrip)
       categoriesArray.push(disabledByDefault('devtools.screenshot'));
 
-    for (var traceProvider of this._extensionTraceProviders)
-      traceProvider.start();
-
+    this._extensionSessions = providers.map(provider => new Timeline.ExtensionTracingSession(provider, this._delegate));
+    this._extensionSessions.forEach(session => session.start());
     var categories = categoriesArray.join(',');
-    this._startRecordingWithCategories(categories, enableJSSampling);
+    this._startRecordingWithCategories(categories, options.enableJSSampling);
   }
 
   stopRecording() {
     var tracingStoppedPromises = [];
     tracingStoppedPromises.push(new Promise(resolve => this._tracingCompleteCallback = resolve));
     tracingStoppedPromises.push(this._stopProfilingOnAllTargets());
     this._target.tracingManager.stop();
 
     if (!Runtime.experiments.isEnabled('timelineRuleUsageRecording') || !this._markUnusedCSS.get())
       tracingStoppedPromises.push(SDK.targetManager.resumeAllTargets());
     else
       this._addUnusedRulesToCoverage();
 
-    Promise.all(tracingStoppedPromises).then(() => this._allSourcesFinished());
-
     this._delegate.loadingStarted();
 
-    for (var traceProvider of this._extensionTraceProviders)
-      traceProvider.stop();
+    var extensionCompletionPromises = this._extensionSessions.map(session => session.stop());
+    if (extensionCompletionPromises.length) {
+      var timerId;
+      var timeoutPromise = new Promise(fulfill => timerId = setTimeout(fulfill, 5000));
+      tracingStoppedPromises.push(
+          Promise.race([Promise.all(extensionCompletionPromises).then(() => clearTimeout(timerId)), timeoutPromise]));
+    }
+    Promise.all(tracingStoppedPromises).then(() => this._allSourcesFinished());
   }
 
   /**
    * @override
    * @param {!SDK.Target} target
    */
   targetAdded(target) {
     this._targets.push(target);
     if (this._profiling)
       this._startProfilingOnTarget(target);
@@ skipping 198 matching lines @@
   }
 
   /**
    * @param {number} progress
    * @override
    */
   eventsRetrievalProgress(progress) {
     this._delegate.loadingProgress(progress);
   }
 };
+
+/** @typedef {!{
+ *    captureCauses: (boolean|undefined),
+ *    enableJSSampling: (boolean|undefined),
+ *    captureMemory: (boolean|undefined),
+ *    capturePictures: (boolean|undefined),
+ *    captureFilmStrip: (boolean|undefined)
+ *  }}
+ */
+Timeline.TimelineController.CaptureOptions;