Revert of DevTools: move flow events tracking to TracingModel, support cross-threads case

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 100 matching lines @@
   }
 
   /**
    * @return {!Array.<!SDK.TracingModel.Event>}
    */
   devToolsMetadataEvents() {
     return this._devToolsMetadataEvents;
   }
 
   /**
-   * @return {!Array.<!SDK.TracingModel.Event>}
-   */
-  flowHeads() {
-    return this._flowHeads;
-  }
-
-  /**
    * @param {!Array.<!SDK.TracingManager.EventPayload>} events
    */
   setEventsForTest(events) {
     this.reset();
     this.addEvents(events);
     this.tracingComplete();
   }
 
   /**
    * @param {!Array.<!SDK.TracingManager.EventPayload>} events
    */
   addEvents(events) {
     for (var i = 0; i < events.length; ++i)
       this._addEvent(events[i]);
   }
 
   tracingComplete() {
     this._processPendingAsyncEvents();
-    this._processFlowEvents();
     this._backingStorage.appendString(this._firstWritePending ? '[]' : ']');
     this._backingStorage.finishWriting();
     this._firstWritePending = false;
     for (var process of this._processById.values()) {
       for (var thread of process._threads.values())
         thread.tracingComplete();
     }
   }
 
   reset() {
     /** @type {!Map<(number|string), !SDK.TracingModel.Process>} */
     this._processById = new Map();
     this._processByName = new Map();
     this._minimumRecordTime = 0;
     this._maximumRecordTime = 0;
     this._devToolsMetadataEvents = [];
     if (!this._firstWritePending)
       this._backingStorage.reset();
 
     this._firstWritePending = true;
     /** @type {!Array<!SDK.TracingModel.Event>} */
     this._asyncEvents = [];
     /** @type {!Map<string, !SDK.TracingModel.AsyncEvent>} */
     this._openAsyncEvents = new Map();
     /** @type {!Map<string, !Array<!SDK.TracingModel.AsyncEvent>>} */
     this._openNestableAsyncEvents = new Map();
-    /** @type {!Map<string, !Array<!SDK.TracingModel.Event>>} */
-    this._flowEventsById = new Map();
     /** @type {!Map<string, !SDK.TracingModel.ProfileEventsGroup>} */
     this._profileGroups = new Map();
     /** @type {!Map<string, !Set<string>>} */
     this._parsedCategories = new Map();
-    /** @type {!Array<!SDK.TracingModel.Event>} */
-    this._flowHeads = [];
   }
 
   /**
    * @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()) {
@@ skipping 45 matching lines @@
     const event = process._addEvent(payload);
     if (!event)
       return;
     if (payload.ph === phase.Sample) {
       this._addSampleEvent(event);
       return;
     }
     // Build async event when we've got events from all threads & processes, so we can sort them and process in the
     // chronological order. However, also add individual async events to the thread flow (above), so we can easily
     // display them on the same chart as other events, should we choose so.
-    if (SDK.TracingModel.isAsyncPhase(payload.ph)) {
+    if (SDK.TracingModel.isAsyncPhase(payload.ph))
       this._asyncEvents.push(event);
-    } else if (SDK.TracingModel.isFlowPhase(payload.ph)) {
-      var key = `${event.categoriesString}-${event.name}-${event.id}`;
-      var flowEvents = this._flowEventsById.get(key);
-      if (!flowEvents) {
-        flowEvents = [];
-        this._flowEventsById.set(key, flowEvents);
-      }
-      flowEvents.push(event);
-    }
-
     event._setBackingStorage(backingStorage);
     if (event.hasCategory(SDK.TracingModel.DevToolsMetadataEventCategory))
       this._devToolsMetadataEvents.push(event);
 
     if (payload.ph !== phase.Metadata)
       return;
 
     switch (payload.name) {
       case SDK.TracingModel.MetadataEvent.ProcessSortIndex:
         process._setSortIndex(payload.args['sort_index']);
@@ skipping 76 matching lines @@
       var event = this._asyncEvents[i];
       if (SDK.TracingModel.isNestableAsyncPhase(event.phase))
         this._addNestableAsyncEvent(event);
       else
         this._addAsyncEvent(event);
     }
     this._asyncEvents = [];
     this._closeOpenAsyncEvents();
   }
 
-  _processFlowEvents() {
-    var phases = SDK.TracingModel.Phase;
-    for (var events of this._flowEventsById.values()) {
-      events.stableSort(SDK.TracingModel.Event.compareStartTime);
-      var lastInChain = null;
-      for (var e of events) {
-        if (lastInChain && e.phase !== phases.FlowBegin)
-          lastInChain._appendFlowEvent(e);
-        if (!lastInChain && e.phase !== phases.FlowEnd)
-          this._flowHeads.push(e);
-        lastInChain = e.phase !== phases.FlowEnd ? e : null;
-      }
-    }
-    this._flowEventsById.clear();
-  }
-
   _closeOpenAsyncEvents() {
     for (var event of this._openAsyncEvents.values()) {
       event.setEndTime(this._maximumRecordTime);
       // FIXME: remove this once we figure a better way to convert async console
       // events to sync [waterfall] timeline records.
       event.steps[0].setEndTime(this._maximumRecordTime);
     }
     this._openAsyncEvents.clear();
 
     for (var eventStack of this._openNestableAsyncEvents.values()) {
@@ skipping 176 matching lines @@
     /** @type {string} */
     this.name = name;
     /** @type {!SDK.TracingModel.Phase} */
     this.phase = phase;
     /** @type {number} */
     this.startTime = startTime;
     /** @type {!SDK.TracingModel.Thread} */
     this.thread = thread;
     /** @type {!Object} */
     this.args = {};
-    /** @type {!SDK.TracingModel.Event|undefined} */
-    this.nextFlow;
-    /** @type {!SDK.TracingModel.Event|undefined} */
-    this.previousFlow;
 
     /** @type {number} */
     this.selfTime = 0;
   }
 
   /**
    * @param {!SDK.TracingManager.EventPayload} payload
    * @param {!SDK.TracingModel.Thread} thread
    * @return {!SDK.TracingModel.Event}
    */
@@ skipping 83 matching lines @@
    */
   _complete(endEvent) {
     if (endEvent.args)
       this.addArgs(endEvent.args);
     else
       console.error('Missing mandatory event argument \'args\' at ' + endEvent.startTime);
     this.setEndTime(endEvent.startTime);
   }
 
   /**
-   * @param {!SDK.TracingModel.Event} nextFlow
-   */
-  _appendFlowEvent(nextFlow) {
-    this.nextFlow = nextFlow;
-    nextFlow.previousFlow = this;
-  }
-
-  /**
    * @param {?function():!Promise.<?string>} backingStorage
    */
   _setBackingStorage(backingStorage) {
   }
 };
 
 SDK.TracingModel.ObjectSnapshot = class extends SDK.TracingModel.Event {
   /**
    * @param {string} category
    * @param {string} name
@@ skipping 339 matching lines @@
     return this._events;
   }
 
   /**
    * @return {!Array.<!SDK.TracingModel.AsyncEvent>}
    */
   asyncEvents() {
     return this._asyncEvents;
   }
 };