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}`;

[pfeldman, 2017/03/16 07:03:50]

I don't think categoriesString and event name should be a part of the key.

Overall, I'm looking at this +172 lines, -55 lines patch and I wonder why we are
adding all this complexity. The code was very readable before the change and now
it somewhat cryptic. I don't think we need this sorting, complex keys and model
api for our scenarios. I want to implement the tree shaking and I don't think
I'm going to use this API. At the same time, rendering code is now more complex.
All it all it seems complexity for the sake of complexity, so I wonder, why?

+      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);

[pfeldman, 2017/03/16 02:00:22]

So if there is no begin, you still consider it a head?

+        lastInChain = e.phase !== phases.FlowEnd ? e : null;

[pfeldman, 2017/03/16 02:00:22]

why do you need all this logic? it is either begin-step-step-step-end or there
is a bug. if there is a bug, but consider the first one begin and the last one
an end.

+      }
+    }
+    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;
   }
 };