DevTools: add extension API to contribute trace events to timeline

third_party/WebKit/Source/devtools/front_end/sdk/TracingModel.js

 /*
  * Copyright 2014 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.
  */
 
 /**
  * @unrestricted
  */
 SDK.TracingModel = class {
@@ skipping 151 matching lines @@
     this._openAsyncEvents = new Map();
     /** @type {!Map<string, !Array<!SDK.TracingModel.AsyncEvent>>} */
     this._openNestableAsyncEvents = new Map();
     /** @type {!Map<string, !SDK.TracingModel.ProfileEventsGroup>} */
     this._profileGroups = new Map();
     /** @type {!Map<string, !Set<string>>} */
     this._parsedCategories = new Map();
   }
 
   /**
+   * @param {number} offset
+   */
+  adjustTime(offset) {
+    this._minimumRecordTime += offset;
+    this._maximumRecordTime += offset;
+    for (const process of this._processById.values()) {
+      for (const thread of process._threads.values()) {
+        for (const event of thread.events()) {
+          event.startTime += offset;
+          if (typeof event.endTime === 'number')
+            event.endTime += offset;
+        }
+        for (const event of thread.asyncEvents()) {
+          event.startTime += offset;
+          if (typeof event.endTime === 'number')
+            event.endTime += offset;
+        }
+      }
+    }
+  }
+
+  /**
    * @param {!SDK.TracingManager.EventPayload} payload
    */
   _addEvent(payload) {
     var process = this._processById.get(payload.pid);
     if (!process) {
       process = new SDK.TracingModel.Process(this, payload.pid);
       this._processById.set(payload.pid, process);
     }
 
     const phase = SDK.TracingModel.Phase;
@@ skipping 285 matching lines @@
   appendString(string) {},
 
   /**
    * @param {string} string
    * @return {function():!Promise.<?string>}
    */
   appendAccessibleString(string) {},
 
   finishWriting() {},
 
-  reset() {},
+  reset() {}
 };
 
 /**
  * @unrestricted
  */
 SDK.TracingModel.Event = class {
   /**
    * @param {string} categories
    * @param {string} name
    * @param {!SDK.TracingModel.Phase} phase
@@ skipping 117 matching lines @@
     this.setEndTime(endEvent.startTime);
   }
 
   /**
    * @param {?function():!Promise.<?string>} backingStorage
    */
   _setBackingStorage(backingStorage) {
   }
 };
 
-
-/**
- * @unrestricted
- */
 SDK.TracingModel.ObjectSnapshot = class extends SDK.TracingModel.Event {
   /**
    * @param {string} category
    * @param {string} name
    * @param {number} startTime
    * @param {!SDK.TracingModel.Thread} thread
    */
   constructor(category, name, startTime, thread) {
     super(category, name, SDK.TracingModel.Phase.SnapshotObject, startTime, thread);
+    /** @type {?function():!Promise<?string>} */
+    this._backingStorage = null;
+    /** @type {string} */
+    this.id;
+    /** @type {?Promise<?>} */
+    this._objectPromise = null;
   }
 
   /**
    * @param {!SDK.TracingManager.EventPayload} payload
    * @param {!SDK.TracingModel.Thread} thread
    * @return {!SDK.TracingModel.ObjectSnapshot}
    */
   static fromPayload(payload, thread) {
     var snapshot = new SDK.TracingModel.ObjectSnapshot(payload.cat, payload.name, payload.ts / 1000, thread);
     var id = SDK.TracingModel._extractId(payload);
@@ skipping 98 matching lines @@
   }
 
   /**
    * @param {!SDK.TracingModel.Event} event
    */
   _addChild(event) {
     this.children.push(event);
   }
 };
 
-/**
- * @unrestricted
- */
 SDK.TracingModel.NamedObject = class {
   /**
+   * @param {!SDK.TracingModel} model
+   * @param {number} id
+   */
+  constructor(model, id) {
+    this._model = model;
+    this._id = id;
+    this._name = '';
+    this._sortIndex = 0;
+  }
+
+  /**
    * @param {!Array.<!SDK.TracingModel.NamedObject>} array
    */
   static _sort(array) {
     /**
      * @param {!SDK.TracingModel.NamedObject} a
      * @param {!SDK.TracingModel.NamedObject} b
      */
     function comparator(a, b) {
       return a._sortIndex !== b._sortIndex ? a._sortIndex - b._sortIndex : a.name().localeCompare(b.name());
     }
@@ skipping 15 matching lines @@
   }
 
   /**
    * @param {number} sortIndex
    */
   _setSortIndex(sortIndex) {
     this._sortIndex = sortIndex;
   }
 };
 
-
-/**
- * @unrestricted
- */
 SDK.TracingModel.Process = class extends SDK.TracingModel.NamedObject {
   /**
    * @param {!SDK.TracingModel} model
    * @param {number} id
    */
   constructor(model, id) {
-    super();
-    this._setName('Process ' + id);
-    this._id = id;
+    super(model, id);
     /** @type {!Map<number, !SDK.TracingModel.Thread>} */
     this._threads = new Map();
     this._threadByName = new Map();
-    this._model = model;
   }
 
   /**
    * @return {number}
    */
   id() {
     return this._id;
   }
 
   /**
@@ skipping 34 matching lines @@
   }
 
   /**
    * @return {!Array.<!SDK.TracingModel.Thread>}
    */
   sortedThreads() {
     return SDK.TracingModel.NamedObject._sort(this._threads.valuesArray());
   }
 };
 
-/**
- * @unrestricted
- */
 SDK.TracingModel.Thread = class extends SDK.TracingModel.NamedObject {
   /**
    * @param {!SDK.TracingModel.Process} process
    * @param {number} id
    */
   constructor(process, id) {
-    super();
+    super(process._model, id);
     this._process = process;
-    this._setName('Thread ' + id);
     this._events = [];
     this._asyncEvents = [];
-    this._id = id;
-    this._model = process._model;
+    this._lastTopLevelEvent = null;
   }
 
   tracingComplete() {
     this._asyncEvents.stableSort(SDK.TracingModel.Event.compareStartAndEndTime);
     this._events.stableSort(SDK.TracingModel.Event.compareStartTime);
     var phases = SDK.TracingModel.Phase;
     var stack = [];
     for (var i = 0; i < this._events.length; ++i) {
       var e = this._events[i];
       e.ordinal = i;
@@ skipping 77 matching lines @@
     return this._events;
   }
 
   /**
    * @return {!Array.<!SDK.TracingModel.AsyncEvent>}
    */
   asyncEvents() {
     return this._asyncEvents;
   }
 };