DevTools: extract modules (non-extensions)

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 11 matching lines @@
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
- * @implements {UI.FlameChartDataProvider}
+ * @implements {PerfUI.FlameChartDataProvider}
  * @unrestricted
  */
 Timeline.TimelineFlameChartDataProvider = class {
   /**
    * @param {!TimelineModel.TimelineModel} model
    * @param {!TimelineModel.TimelineFrameModel} frameModel
    * @param {!TimelineModel.TimelineIRModel} irModel
    * @param {!Array<!TimelineModel.TimelineModel.Filter>} filters
    */
   constructor(model, frameModel, irModel, filters) {
     this.reset();
     this._font = '11px ' + Host.fontFamily();
     this._model = model;
     this._filters = filters;
-    /** @type {?UI.FlameChart.TimelineData} */
+    /** @type {?PerfUI.FlameChart.TimelineData} */
     this._timelineData = null;
     this._currentLevel = 0;
     this._frameModel = frameModel;
     this._irModel = irModel;
     this._consoleColorGenerator =
-        new UI.FlameChart.ColorGenerator({min: 30, max: 55}, {min: 70, max: 100, count: 6}, 50, 0.7);
+        new PerfUI.FlameChart.ColorGenerator({min: 30, max: 55}, {min: 70, max: 100, count: 6}, 50, 0.7);
     this._extensionColorGenerator =
-        new UI.FlameChart.ColorGenerator({min: 210, max: 300}, {min: 70, max: 100, count: 6}, 70, 0.7);
+        new PerfUI.FlameChart.ColorGenerator({min: 210, max: 300}, {min: 70, max: 100, count: 6}, 70, 0.7);
 
     const defaultGroupStyle = {
       padding: 4,
       height: 17,
       collapsible: true,
       color: UI.themeSupport.patchColor('#222', UI.ThemeSupport.ColorUsage.Foreground),
       backgroundColor: UI.themeSupport.patchColor('white', UI.ThemeSupport.ColorUsage.Background),
       font: this._font,
       nestingLevel: 0,
       shareHeaderLine: true
     };
 
-    this._headerLevel1 = /** @type {!UI.FlameChart.GroupStyle} */
+    this._headerLevel1 = /** @type {!PerfUI.FlameChart.GroupStyle} */
         (Object.assign({}, defaultGroupStyle, {shareHeaderLine: false}));
-    this._headerLevel2 = /** @type {!UI.FlameChart.GroupStyle} */
+    this._headerLevel2 = /** @type {!PerfUI.FlameChart.GroupStyle} */
         (Object.assign({}, defaultGroupStyle, {padding: 2, nestingLevel: 1, collapsible: false}));
-    this._staticHeader = /** @type {!UI.FlameChart.GroupStyle} */
+    this._staticHeader = /** @type {!PerfUI.FlameChart.GroupStyle} */
         (Object.assign({}, defaultGroupStyle, {collapsible: false}));
-    this._interactionsHeaderLevel1 = /** @type {!UI.FlameChart.GroupStyle} */
+    this._interactionsHeaderLevel1 = /** @type {!PerfUI.FlameChart.GroupStyle} */
         (Object.assign({useFirstLineForOverview: true}, defaultGroupStyle));
-    this._interactionsHeaderLevel2 = /** @type {!UI.FlameChart.GroupStyle} */
+    this._interactionsHeaderLevel2 = /** @type {!PerfUI.FlameChart.GroupStyle} */
         (Object.assign({}, defaultGroupStyle, {padding: 2, nestingLevel: 1}));
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {?string}
    */
   entryTitle(entryIndex) {
     var entryType = this._entryType(entryIndex);
@@ skipping 63 matching lines @@
   /**
    * @override
    * @return {number}
    */
   maxStackDepth() {
     return this._currentLevel;
   }
 
   /**
    * @override
-   * @return {!UI.FlameChart.TimelineData}
+   * @return {!PerfUI.FlameChart.TimelineData}
    */
   timelineData() {
     if (this._timelineData)
       return this._timelineData;
 
-    this._timelineData = new UI.FlameChart.TimelineData([], [], [], []);
+    this._timelineData = new PerfUI.FlameChart.TimelineData([], [], [], []);
 
     this._minimumBoundary = this._model.minimumRecordTime();
     this._timeSpan = this._model.isEmpty() ? 1000 : this._model.maximumRecordTime() - this._minimumBoundary;
     this._currentLevel = 0;
 
     this._appendHeader(Common.UIString('Frames'), this._staticHeader);
     this._appendFrameBars(this._frameModel.frames());
 
     this._appendHeader(Common.UIString('Interactions'), this._interactionsHeaderLevel1);
     this._appendInteractionRecords();
@@ skipping 76 matching lines @@
   /**
    * @param {number} level
    * @param {!TimelineModel.TimelineModel.PageFrame} frame
    */
   _appendFrameEvents(level, frame) {
     var events = this._model.eventsForFrame(frame.id);
     var clonedHeader = Object.assign({}, this._headerLevel1);
     clonedHeader.nestingLevel = level;
     this._appendSyncEvents(
         events, Timeline.TimelineUIUtils.displayNameForFrame(frame),
-        /** @type {!UI.FlameChart.GroupStyle} */ (clonedHeader), Timeline.TimelineFlameChartEntryType.Event);
+        /** @type {!PerfUI.FlameChart.GroupStyle} */ (clonedHeader), Timeline.TimelineFlameChartEntryType.Event);
     frame.children.forEach(this._appendFrameEvents.bind(this, level + 1));
   }
 
   /**
    * @param {string} threadTitle
    * @param {!Array<!SDK.TracingModel.Event>} syncEvents
    * @param {!Map<!TimelineModel.TimelineModel.AsyncEventGroup, !Array<!SDK.TracingModel.AsyncEvent>>} asyncEvents
    * @param {boolean=} forceExpanded
    */
   _appendThreadTimelineData(threadTitle, syncEvents, asyncEvents, forceExpanded) {
     var entryType = Timeline.TimelineFlameChartEntryType.Event;
     this._appendAsyncEvents(asyncEvents);
     this._appendSyncEvents(syncEvents, threadTitle, this._headerLevel1, entryType, forceExpanded);
   }
 
   /**
    * @param {!Array<!SDK.TracingModel.Event>} events
    * @param {string} title
-   * @param {!UI.FlameChart.GroupStyle} style
+   * @param {!PerfUI.FlameChart.GroupStyle} style
    * @param {!Timeline.TimelineFlameChartEntryType} entryType
    * @param {boolean=} forceExpanded
    */
   _appendSyncEvents(events, title, style, entryType, forceExpanded) {
     var isExtension = entryType === Timeline.TimelineFlameChartEntryType.ExtensionEvent;
     var openEvents = [];
     var blackboxingEnabled = !isExtension && Runtime.experiments.isEnabled('blackboxJSFramesOnTimeline');
     var maxStackDepth = 0;
     for (var i = 0; i < events.length; ++i) {
       var e = events[i];
@@ skipping 74 matching lines @@
       if (!events)
         continue;
       var title = Timeline.TimelineUIUtils.titleForAsyncEventGroup(group);
       this._appendAsyncEventsGroup(title, events, this._headerLevel1, entryType);
     }
   }
 
   /**
    * @param {string} header
    * @param {!Array<!SDK.TracingModel.AsyncEvent>} events
-   * @param {!UI.FlameChart.GroupStyle} style
+   * @param {!PerfUI.FlameChart.GroupStyle} style
    * @param {!Timeline.TimelineFlameChartEntryType} entryType
    */
   _appendAsyncEventsGroup(header, events, style, entryType) {
     var lastUsedTimeByLevel = [];
     var groupHeaderAppended = false;
     for (var i = 0; i < events.length; ++i) {
       var asyncEvent = events[i];
       if (!this._isVisible(asyncEvent))
         continue;
       if (!groupHeaderAppended) {
@@ skipping 253 matching lines @@
 
     this._appendHeader(entry.title, this._headerLevel1);
     for (let thread of allThreads) {
       this._appendAsyncEventsGroup(thread.name(), thread.asyncEvents(), this._headerLevel2, entryType);
       this._appendSyncEvents(thread.events(), thread.name(), this._headerLevel2, entryType, false);
     }
   }
 
   /**
    * @param {string} title
-   * @param {!UI.FlameChart.GroupStyle} style
+   * @param {!PerfUI.FlameChart.GroupStyle} style
    * @param {boolean=} expanded
    */
   _appendHeader(title, style, expanded) {
     this._timelineData.groups.push({startLevel: this._currentLevel, name: title, expanded: expanded, style: style});
   }
 
   /**
    * @param {!SDK.TracingModel.Event} event
    * @param {number} level
    */
@@ skipping 123 matching lines @@
    * @return {boolean}
    */
   _isVisible(event) {
     return this._filters.every(function(filter) {
       return filter.accept(event);
     });
   }
 };
 
 Timeline.TimelineFlameChartDataProvider.InstantEventVisibleDurationMs = 0.001;