Timeline: get collapsible row groups on FlameChart out of 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 244 matching lines @@
     _isVisible: function(event)
     {
         return this._filters.every(function (filter) { return filter.accept(event); });
     }
 }
 
 /**
  * @enum {symbol}
  */
 WebInspector.TimelineFlameChartEntryType = {
-    Header: Symbol("Header"),
     Frame: Symbol("Frame"),
     Event: Symbol("Event"),
     InteractionRecord: Symbol("InteractionRecord"),
 };
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineFlameChartDataProviderBase}
  * @param {!WebInspector.TimelineModel} model
  * @param {!WebInspector.TimelineFrameModelBase} frameModel
@@ skipping 76 matching lines @@
         else
             return WebInspector.TimelineFlameChartDataProviderBase.prototype.textColor.call(this, index);
     },
 
     /**
      * @override
      */
     reset: function()
     {
         WebInspector.TimelineFlameChartDataProviderBase.prototype.reset.call(this);
-        /** @type {!Array<!WebInspector.TracingModel.Event|!WebInspector.TimelineFrame|!WebInspector.TimelineIRModel.Phases|null>} */
+        /** @type {!Array<!WebInspector.TracingModel.Event|!WebInspector.TimelineFrame|!WebInspector.TimelineIRModel.Phases>} */
         this._entryData = [];
         /** @type {!Array<!WebInspector.TimelineFlameChartEntryType>} */
         this._entryTypeByLevel = [];
         /** @type {!Array<string>} */
         this._entryIndexToTitle = [];
         /** @type {!Array.<!WebInspector.TimelineFlameChartMarker>} */
         this._markers = [];
         this._asyncColorByCategory = {};
     },
 
     /**
      * @override
      * @return {!WebInspector.FlameChart.TimelineData}
      */
     timelineData: function()
     {
         if (this._timelineData)
             return this._timelineData;
 
         this._timelineData = new WebInspector.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._appendInteractionRecords();
-        this._appendThreadTimelineData(WebInspector.UIString("Main Thread"), this._model.mainThreadEvents(), this._model.mainThreadAsyncEvents(), true);
-        if (Runtime.experiments.isEnabled("gpuTimeline"))
-            this._appendGPUEvents();
 
         var threads = this._model.virtualThreads();
-        var compositorThreads;
-        var otherThreads;
-        if (Runtime.experiments.isEnabled("timelineCollapsible")) {
-            compositorThreads = threads.filter(thread => thread.name.startsWith("CompositorTileWorker"));
-            otherThreads = threads.filter(thread => !thread.name.startsWith("CompositorTileWorker"));
-        } else {
-            compositorThreads = [];
-            otherThreads = threads;
-        }
-        otherThreads.forEach(thread => this._appendThreadTimelineData(thread.name, thread.events, thread.asyncEventsByGroup));
+        var compositorThreads = threads.filter(thread => thread.name.startsWith("CompositorTileWorker"));
+        var otherThreads = threads.filter(thread => !thread.name.startsWith("CompositorTileWorker"));
         if (compositorThreads.length) {
             this._appendHeader(WebInspector.UIString("Rasterizer Threads"), this._headerLevel1);
             for (var i = 0; i < compositorThreads.length; ++i)
                 this._appendSyncEvents(compositorThreads[i].events, WebInspector.UIString("Rasterizer Thread %d", i), this._headerLevel2);
         }
 
+        this._appendThreadTimelineData(WebInspector.UIString("Main Thread"), this._model.mainThreadEvents(), this._model.mainThreadAsyncEvents(), true);
+        if (Runtime.experiments.isEnabled("gpuTimeline"))
+            this._appendGPUEvents();
+
+        otherThreads.forEach(thread => this._appendThreadTimelineData(thread.name, thread.events, thread.asyncEventsByGroup));
+
         /**
          * @param {!WebInspector.TimelineFlameChartMarker} a
          * @param {!WebInspector.TimelineFlameChartMarker} b
          */
         function compareStartTime(a, b)
         {
             return a.startTime() - b.startTime();
         }
 
         this._markers.sort(compareStartTime);
@@ skipping 228 matching lines @@
             var color = this._asyncColorByCategory[category.name];
             if (color)
                 return color;
             var parsedColor = WebInspector.Color.parse(category.color);
             color = parsedColor.setAlpha(0.7).asString(WebInspector.Color.Format.RGBA) || "";
             this._asyncColorByCategory[category.name] = color;
             return color;
         }
         if (type === WebInspector.TimelineFlameChartEntryType.Frame)
             return "white";
-        if (type === WebInspector.TimelineFlameChartEntryType.Header)
-            return "#aaa";
         if (type === WebInspector.TimelineFlameChartEntryType.InteractionRecord)
             return WebInspector.TimelineUIUtils.interactionPhaseColor(/** @type {!WebInspector.TimelineIRModel.Phases} */ (this._entryData[entryIndex]));
         return "";
     },
 
     /**
      * @override
      * @param {number} entryIndex
      * @param {!CanvasRenderingContext2D} context
      * @param {?string} text
@@ skipping 69 matching lines @@
             type === WebInspector.TimelineFlameChartEntryType.Event && !!/** @type {!WebInspector.TracingModel.Event} */ (this._entryData[entryIndex]).warning;
     },
 
     /**
      * @param {string} title
      * @param {!WebInspector.FlameChart.GroupStyle} style
      * @param {boolean=} expanded
      */
     _appendHeader: function(title, style, expanded)
     {
-        if (Runtime.experiments.isEnabled("timelineCollapsible"))
-            this._timelineData.groups.push({startLevel: this._currentLevel, name: title, expanded: expanded, style: style});
-        else
-            this._appendHeaderRecord(title)
+        this._timelineData.groups.push({startLevel: this._currentLevel, name: title, expanded: expanded, style: style});
     },
 
     /**
-     * @param {string} title
-     */
-    _appendHeaderRecord: function(title)
-    {
-        var index = this._entryData.length;
-        this._entryIndexToTitle[index] = title;
-        this._entryData.push(null);
-        this._entryTypeByLevel[this._currentLevel] = WebInspector.TimelineFlameChartEntryType.Header;
-        this._timelineData.entryLevels[index] = this._currentLevel++;
-        this._timelineData.entryTotalTimes[index] = this._timeSpan;
-        this._timelineData.entryStartTimes[index] = this._minimumBoundary;
-    },
-
-    /**
      * @param {!WebInspector.TracingModel.Event} event
      * @param {number} level
      */
     _appendEvent: function(event, level)
     {
         var index = this._entryData.length;
         this._entryData.push(event);
         this._timelineData.entryLevels[index] = level;
         this._timelineData.entryTotalTimes[index] = event.duration || WebInspector.TimelineFlameChartDataProvider.InstantEventVisibleDurationMs;
         this._timelineData.entryStartTimes[index] = event.startTime;
@@ skipping 691 matching lines @@
 /**
   * @constructor
   * @param {!WebInspector.TimelineSelection} selection
   * @param {number} entryIndex
   */
 WebInspector.TimelineFlameChartView.Selection = function(selection, entryIndex)
 {
     this.timelineSelection = selection;
     this.entryIndex = entryIndex;
 }