[DevTools] Turn starting tracing into promise.

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.
 
 /**
  * @implements {SDK.TargetManager.Observer}
  * @implements {SDK.TracingManagerClient}
  * @unrestricted
  */
 Timeline.TimelineController = class {
@@ skipping 15 matching lines @@
     /** @type {!Array<!SDK.Target>} */
     this._targets = [];
     /** @type {!Array<!Timeline.ExtensionTracingSession>} */
     this._extensionSessions = [];
     SDK.targetManager.observeTargets(this);
   }
 
   /**
    * @param {!Timeline.TimelineController.RecordingOptions} options
    * @param {!Array<!Extensions.ExtensionTraceProvider>} providers
+   * @return {!Promise}
    */
   startRecording(options, providers) {
     this._extensionTraceProviders = Extensions.extensionServer.traceProviders().slice();
 
     /**
      * @param {string} category
      * @return {string}
      */
     function disabledByDefault(category) {
       return 'disabled-by-default-' + category;
@@ skipping 19 matching lines @@
       categoriesArray.push(
           disabledByDefault('devtools.timeline.layers'), disabledByDefault('devtools.timeline.picture'),
           disabledByDefault('blink.graphics_context_annotations'));
     }
     if (options.captureFilmStrip)
       categoriesArray.push(disabledByDefault('devtools.screenshot'));
 
     this._extensionSessions =
         providers.map(provider => new Timeline.ExtensionTracingSession(provider, this._performanceModel));
     this._extensionSessions.forEach(session => session.start());
-    this._startRecordingWithCategories(categoriesArray.join(','), options.enableJSSampling);
+    var startPromise = this._startRecordingWithCategories(categoriesArray.join(','), options.enableJSSampling);
     this._performanceModel.setRecordStartTime(Date.now());
+    return startPromise;
   }
 
   stopRecording() {
     var tracingStoppedPromises = [];
     tracingStoppedPromises.push(new Promise(resolve => this._tracingCompleteCallback = resolve));
     tracingStoppedPromises.push(this._stopProfilingOnAllTargets());
     this._target.tracingManager.stop();
     tracingStoppedPromises.push(SDK.targetManager.resumeAllTargets());
 
     this._client.loadingStarted();
@@ skipping 75 matching lines @@
    */
   _stopProfilingOnAllTargets() {
     var targets = this._profiling ? this._targets : [];
     this._profiling = false;
     return Promise.all(targets.map(this._stopProfilingOnTarget, this));
   }
 
   /**
    * @param {string} categories
    * @param {boolean=} enableJSSampling
-   * @param {function(?string)=} callback
+   * @return {!Promise}
    */
-  _startRecordingWithCategories(categories, enableJSSampling, callback) {
+  _startRecordingWithCategories(categories, enableJSSampling) {
     SDK.targetManager.suspendAllTargets();
     var profilingStartedPromise = enableJSSampling && !Runtime.experiments.isEnabled('timelineTracingJSProfile') ?
         this._startProfilingOnAllTargets() :
         Promise.resolve();
     var samplingFrequencyHz = Common.moduleSetting('highResolutionCpuProfiling').get() ? 10000 : 1000;
     var options = 'sampling-frequency=' + samplingFrequencyHz;
-    var target = this._target;
-    var tracingManager = target.tracingManager;
-    SDK.targetManager.suspendReload(target);
-    profilingStartedPromise.then(tracingManager.start.bind(tracingManager, this, categories, options, onTraceStarted));
-    /**
-     * @param {?string} error
-     */
-    function onTraceStarted(error) {
-      SDK.targetManager.resumeReload(target);
-      if (callback)
-        callback(error);
-    }
+    var tracingManager = this._target.tracingManager;
+    return profilingStartedPromise.then(() => tracingManager.start(this, categories, options));

[alph, 2017/02/28 03:11:24]

nit: await

   }
 
   /**
-   * @override
-   */
-  tracingStarted() {
-    this._client.recordingStarted();
-  }
-
-  /**
    * @param {!Array.<!SDK.TracingManager.EventPayload>} events
    * @override
    */
   traceEventsCollected(events) {
     this._tracingModel.addEvents(events);
   }
 
   /**
    * @override
    */
@@ skipping 78 matching lines @@
   }
 };
 
 /**
  * @interface
  * @extends {Timeline.TimelineLoader.Client}
  */
 Timeline.TimelineController.Client = function() {};
 
 Timeline.TimelineController.Client.prototype = {
-  recordingStarted() {},
-
   /**
    * @param {number} usage
    */
   recordingProgress(usage) {},
 };
 
 /**
  * @typedef {!{
  *   enableJSSampling: (boolean|undefined),
  *   capturePictures: (boolean|undefined),
  *   captureFilmStrip: (boolean|undefined)
  * }}
  */
 Timeline.TimelineController.RecordingOptions;