Timeline: nuke flow events experiment

third_party/WebKit/Source/devtools/front_end/timeline/TimelineFlameChart.js

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 141 matching lines @@
   /**
    * @override
    * @return {!UI.FlameChart.TimelineData}
    */
   timelineData() {
     if (this._timelineData)
       return this._timelineData;
 
     this._timelineData = new UI.FlameChart.TimelineData([], [], [], []);
 
-    this._flowEventIndexById = {};
     this._minimumBoundary = this._model.minimumRecordTime();
     this._timeSpan = this._model.isEmpty() ? 1000 : this._model.maximumRecordTime() - this._minimumBoundary;
     this._currentLevel = 0;
     this._appendFrameBars(this._frameModel.frames());
 
     this._appendHeader(Common.UIString('Interactions'), this._interactionsHeaderLevel1);
     this._appendInteractionRecords();
 
     var asyncEventGroups = TimelineModel.TimelineModel.AsyncEventGroup;
     var inputLatencies = this._model.mainThreadAsyncEvents().get(asyncEventGroups.input);
@@ skipping 37 matching lines @@
      * @param {!Timeline.TimelineFlameChartMarker} a
      * @param {!Timeline.TimelineFlameChartMarker} b
      */
     function compareStartTime(a, b) {
       return a.startTime() - b.startTime();
     }
 
     this._markers.sort(compareStartTime);
     this._timelineData.markers = this._markers;
 
-    this._flowEventIndexById = {};
     return this._timelineData;
   }
 
   /**
    * @param {number} level
    * @param {!TimelineModel.TimelineModel.PageFrame} frame
    */
   _appendFrameEvents(level, frame) {
     var events = this._model.eventsForFrame(frame.id);
     var clonedHeader = Object.assign({}, this._headerLevel1);
@@ skipping 16 matching lines @@
   }
 
   /**
    * @param {!Array<!SDK.TracingModel.Event>} events
    * @param {string} title
    * @param {!UI.FlameChart.GroupStyle} style
    * @param {boolean=} forceExpanded
    */
   _appendSyncEvents(events, title, style, forceExpanded) {
     var openEvents = [];
-    var flowEventsEnabled = Runtime.experiments.isEnabled('timelineFlowEvents');
     var blackboxingEnabled = Runtime.experiments.isEnabled('blackboxJSFramesOnTimeline');
     var maxStackDepth = 0;
     for (var i = 0; i < events.length; ++i) {
       var e = events[i];
       if (TimelineModel.TimelineModel.isMarkerEvent(e)) {
         this._markers.push(new Timeline.TimelineFlameChartMarker(
             e.startTime, e.startTime - this._model.minimumRecordTime(),
             Timeline.TimelineUIUtils.markerStyleForEvent(e)));
       }
       if (!SDK.TracingModel.isFlowPhase(e.phase)) {
@@ skipping 13 matching lines @@
           continue;
         e._blackboxRoot = true;
       }
       if (title) {
         this._appendHeader(title, style, forceExpanded);
         title = '';
       }
 
       var level = this._currentLevel + openEvents.length;
       this._appendEvent(e, level);
-      if (flowEventsEnabled)
-        this._appendFlowEvent(e, level);
       maxStackDepth = Math.max(maxStackDepth, openEvents.length + 1);
       if (e.endTime)
         openEvents.push(e);
     }
     this._entryTypeByLevel.length = this._currentLevel + maxStackDepth;
     this._entryTypeByLevel.fill(Timeline.TimelineFlameChartEntryType.Event, this._currentLevel);
     this._currentLevel += maxStackDepth;
   }
 
   /**
@@ skipping 297 matching lines @@
     var duration;
     if (TimelineModel.TimelineModel.isMarkerEvent(event))
       duration = undefined;
     else
       duration = event.duration || Timeline.TimelineFlameChartDataProvider.InstantEventVisibleDurationMs;
     this._timelineData.entryTotalTimes[index] = duration;
     this._timelineData.entryStartTimes[index] = event.startTime;
   }
 
   /**
-   * @param {!SDK.TracingModel.Event} event
-   * @param {number} level
-   */
-  _appendFlowEvent(event, level) {
-    var timelineData = this._timelineData;
-    /**
-     * @param {!SDK.TracingModel.Event} event
-     * @return {number}
-     */
-    function pushStartFlow(event) {
-      var flowIndex = timelineData.flowStartTimes.length;
-      timelineData.flowStartTimes.push(event.startTime);
-      timelineData.flowStartLevels.push(level);
-      return flowIndex;
-    }
-
-    /**
-     * @param {!SDK.TracingModel.Event} event
-     * @param {number} flowIndex
-     */
-    function pushEndFlow(event, flowIndex) {
-      timelineData.flowEndTimes[flowIndex] = event.startTime;
-      timelineData.flowEndLevels[flowIndex] = level;
-    }
-
-    switch (event.phase) {
-      case SDK.TracingModel.Phase.FlowBegin:
-        this._flowEventIndexById[event.id] = pushStartFlow(event);
-        break;
-      case SDK.TracingModel.Phase.FlowStep:
-        pushEndFlow(event, this._flowEventIndexById[event.id]);
-        this._flowEventIndexById[event.id] = pushStartFlow(event);
-        break;
-      case SDK.TracingModel.Phase.FlowEnd:
-        pushEndFlow(event, this._flowEventIndexById[event.id]);
-        delete this._flowEventIndexById[event.id];
-        break;
-    }
-  }
-
-  /**
    * @param {!SDK.TracingModel.AsyncEvent} asyncEvent
    * @param {number} level
    */
   _appendAsyncEvent(asyncEvent, level) {
     if (SDK.TracingModel.isNestableAsyncPhase(asyncEvent.phase)) {
       // FIXME: also add steps once we support event nesting in the FlameChart.
       this._appendEvent(asyncEvent, level);
       return;
     }
     var steps = asyncEvent.steps;
@@ skipping 75 matching lines @@
    * @param {!SDK.TracingModel.Event} event
    * @return {?Timeline.TimelineSelection} selection
    */
   selectionForEvent(event) {
     var entryIndex = this._entryData.indexOf(event);
     return this.createSelection(entryIndex);
   }
 };
 
 Timeline.TimelineFlameChartDataProvider.InstantEventVisibleDurationMs = 0.001;