[DevTools] Turn TracingManager into SDKModel.

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.SDKModelObserver<!SDK.CPUProfilerModel>}
  * @implements {SDK.TracingManagerClient}
  * @unrestricted
  */
 Timeline.TimelineController = class {
   /**
-   * @param {!SDK.Target} target
+   * @param {!SDK.TracingManager} tracingManager
    * @param {!Timeline.PerformanceModel} performanceModel
    * @param {!Timeline.TimelineController.Client} client
    */
-  constructor(target, performanceModel, client) {
-    this._target = target;
+  constructor(tracingManager, performanceModel, client) {
+    this._tracingManager = tracingManager;
     this._performanceModel = performanceModel;
     this._client = client;
 
     this._tracingModelBackingStorage = new Bindings.TempFileBackingStorage('tracing');
     this._tracingModel = new SDK.TracingModel(this._tracingModelBackingStorage);
 
-    this._performanceModel.setMainTarget(target);
+    this._performanceModel.setMainTarget(tracingManager.target());
 
     /** @type {!Array<!Timeline.ExtensionTracingSession>} */
     this._extensionSessions = [];
     SDK.targetManager.observeModels(SDK.CPUProfilerModel, this);
   }
 
   /**
    * @param {!Timeline.TimelineController.RecordingOptions} options
    * @param {!Array<!Extensions.ExtensionTraceProvider>} providers
    * @return {!Promise}
@@ skipping 38 matching lines @@
     this._extensionSessions.forEach(session => session.start());
     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._stopProfilingOnAllModels());
-    this._target.tracingManager.stop();
+    this._tracingManager.stop();
     tracingStoppedPromises.push(SDK.targetManager.resumeAllTargets());
 
     this._client.loadingStarted();
 
     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]));
@@ skipping 62 matching lines @@
    * @param {boolean=} enableJSSampling
    * @return {!Promise}
    */
   _startRecordingWithCategories(categories, enableJSSampling) {
     SDK.targetManager.suspendAllTargets();
     var profilingStartedPromise = enableJSSampling && !Runtime.experiments.isEnabled('timelineTracingJSProfile') ?
         this._startProfilingOnAllModels() :
         Promise.resolve();
     var samplingFrequencyHz = Common.moduleSetting('highResolutionCpuProfiling').get() ? 10000 : 1000;
     var options = 'sampling-frequency=' + samplingFrequencyHz;
-    var tracingManager = this._target.tracingManager;
-    return profilingStartedPromise.then(() => tracingManager.start(this, categories, options));
+    return profilingStartedPromise.then(() => this._tracingManager.start(this, categories, options));
   }
 
   /**
    * @param {!Array.<!SDK.TracingManager.EventPayload>} events
    * @override
    */
   traceEventsCollected(events) {
     this._tracingModel.addEvents(events);
   }
 
@@ skipping 41 matching lines @@
       return;
 
     var metadataEventTypes = TimelineModel.TimelineModel.DevToolsMetadataEvent;
     var metadataEvents = this._tracingModel.devToolsMetadataEvents();
     var mainMetaEvent =
         metadataEvents.filter(event => event.name === metadataEventTypes.TracingStartedInPage).peekLast();
     if (!mainMetaEvent)
       return;
 
     var pid = mainMetaEvent.thread.process().id();
-    var mainCpuProfile = this._cpuProfiles.get(this._target.id());
+    var mainCpuProfile = this._cpuProfiles.get(this._tracingManager.target().id());
     this._injectCpuProfileEvent(pid, mainMetaEvent.thread.id(), mainCpuProfile);
 
     var workerMetaEvents = metadataEvents.filter(event => event.name === metadataEventTypes.TracingSessionIdForWorker);
     for (var metaEvent of workerMetaEvents) {
       var workerId = metaEvent.args['data']['workerId'];
-      var workerTarget = SDK.targetManager.targetById(workerId);
-      if (!workerTarget)
-        continue;
-      var cpuProfile = this._cpuProfiles.get(workerTarget.id());
+      var cpuProfile = this._cpuProfiles.get(workerId);

[caseq, 2017/03/01 02:28:06]

Can we really expect that worker id in trace is same as the target id?

       this._injectCpuProfileEvent(
           metaEvent.thread.process().id(), metaEvent.args['data']['workerThreadId'], cpuProfile);
     }
     this._cpuProfiles = null;
   }
 
   /**
    * @param {number} usage
    * @override
    */
@@ skipping 24 matching lines @@
 };
 
 /**
  * @typedef {!{
  *   enableJSSampling: (boolean|undefined),
  *   capturePictures: (boolean|undefined),
  *   captureFilmStrip: (boolean|undefined)
  * }}
  */
 Timeline.TimelineController.RecordingOptions;