Timeline addTraceProvider API

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.
 
 /**
  * @constructor
  * @param {!WebInspector.Target} target
  * @param {!WebInspector.TimelineLifecycleDelegate} delegate
  * @param {!WebInspector.TracingModel} tracingModel
  * @implements {WebInspector.TargetManager.Observer}
  * @implements {WebInspector.TracingManagerClient}
  */
 WebInspector.TimelineController = function(target, delegate, tracingModel)
 {
     this._delegate = delegate;
     this._target = target;
     this._tracingModel = tracingModel;
     this._targets = [];
     this._allProfilesStoppedPromise = Promise.resolve();
     this._targetsResumedPromise = Promise.resolve();
+    this._extensionTraceProviders = WebInspector.extensionServer.traceProviders();
     WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.TimelineController.prototype = {
     /**
      * @param {boolean} captureCauses
      * @param {boolean} enableJSSampling
      * @param {boolean} captureMemory
      * @param {boolean} capturePictures
      * @param {boolean} captureFilmStrip
@@ skipping 29 matching lines @@
         if (captureCauses && Runtime.experiments.isEnabled("timelineInvalidationTracking"))
             categoriesArray.push(disabledByDefault("devtools.timeline.invalidationTracking"));
         if (capturePictures) {
             categoriesArray.push(disabledByDefault("devtools.timeline.layers"),
                                  disabledByDefault("devtools.timeline.picture"),
                                  disabledByDefault("blink.graphics_context_annotations"));
         }
         if (captureFilmStrip)
             categoriesArray.push(disabledByDefault("devtools.screenshot"));
 
+        for (var traceProvider of this._extensionTraceProviders) {
+            traceProvider.run();
+        }
+
         var categories = categoriesArray.join(",");
         this._startRecordingWithCategories(categories, enableJSSampling);
     },
 
     stopRecording: function()
     {
         this._allProfilesStoppedPromise = this._stopProfilingOnAllTargets();
         this._target.tracingManager.stop();
         this._targetsResumedPromise = WebInspector.targetManager.resumeAllTargets();
         this._delegate.loadingStarted();
+
+        var target = WebInspector.targetManager.mainTarget();
+        var requests = target.networkLog.requests().slice();
+        for (var traceProvider of this._extensionTraceProviders) {
+            traceProvider.stop(requests);
+        }
     },
 
     /**
      * @override
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
         this._targets.push(target);
         if (this._profiling)
@@ skipping 92 matching lines @@
                 callback(error);
         }
     },
 
     /**
      * @override
      */
     tracingStarted: function()
     {
         this._tracingModel.reset();
+        for (var provider of this._extensionTraceProviders) {
+          provider.tracingModel.reset();
+        }
         this._delegate.recordingStarted();
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      * @override
      */
     traceEventsCollected: function(events)
     {
         this._tracingModel.addEvents(events);
     },
 
     /**
      * @override
      */
     tracingComplete: function()
     {
         Promise.all([this._allProfilesStoppedPromise, this._targetsResumedPromise])
             .then(this._didStopRecordingTraceEvents.bind(this));
     },
 
     _didStopRecordingTraceEvents: function()
     {
         this._injectCpuProfileEvents();
         this._tracingModel.tracingComplete();
-        this._delegate.loadingComplete(true);
+
+        var count = 0;
+        var total = this._extensionTraceProviders.length;
+        var traceProviders = this._extensionTraceProviders;
+        var this_ = this;
+        var p = new Promise(function(resolve, reject) {

[caseq, 2016/07/11 18:58:38]

Let's piggy-back on the existent allProfilesStoppped prommise:
- rename allProfilesStoppedPromise to allTatrgetsStopped or something other
general enough;
- add one promise per trace provider;
- each promise would resolve either upon associated trace provider returning
data or upon a timeout;

+            for (var traceProvider of traceProviders) {
+                var traceData = traceProvider.traceData;
+                function appendEventsComplete() {
+                    if (traceData.events === null) {
+                        setTimeout(appendEventsComplete, 1000);
+                    } else {
+                        traceProvider.tracingModel.addEvents(traceData.events);
+                        traceProvider.tracingModel.tracingComplete();
+                        count++;
+                    }
+                }
+                appendEventsComplete();
+            }
+            function waitUntil(callback) {
+                setTimeout(function() {
+                count == total ? callback(): waitUntil(callback);}, 1000);
+            }
+            waitUntil(function() {
+                resolve();
+            });
+        });
+        p.then(function() {
+            this_._delegate.loadingComplete(true);
+        });
     },
 
     /**
      * @param {number} pid
      * @param {number} tid
      * @param {?ProfilerAgent.CPUProfile} cpuProfile
      */
     _injectCpuProfileEvent: function(pid, tid, cpuProfile)
     {
         if (!cpuProfile)
@@ skipping 48 matching lines @@
 
     /**
      * @param {number} progress
      * @override
      */
     eventsRetrievalProgress: function(progress)
     {
         this._delegate.loadingProgress(progress);
     }
 }