DevTools: extract modules (non-extensions)

third_party/WebKit/Source/devtools/front_end/profiler/CPUProfileFlameChart.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
  */
 Profiler.ProfileFlameChartDataProvider = class {
   constructor() {
-    UI.FlameChartDataProvider.call(this);
+    PerfUI.FlameChartDataProvider.call(this);
     this._colorGenerator = Profiler.ProfileFlameChartDataProvider.colorGenerator();
   }
 
   /**
-   * @return {!UI.FlameChart.ColorGenerator}
+   * @return {!PerfUI.FlameChart.ColorGenerator}
    */
   static colorGenerator() {
     if (!Profiler.ProfileFlameChartDataProvider._colorGenerator) {
-      var colorGenerator = new UI.FlameChart.ColorGenerator(
+      var colorGenerator = new PerfUI.FlameChart.ColorGenerator(
           {min: 30, max: 330}, {min: 50, max: 80, count: 5}, {min: 80, max: 90, count: 3});
 
       colorGenerator.setColorForID('(idle)', 'hsl(0, 0%, 94%)');
       colorGenerator.setColorForID('(program)', 'hsl(0, 0%, 80%)');
       colorGenerator.setColorForID('(garbage collector)', 'hsl(0, 0%, 80%)');
       Profiler.ProfileFlameChartDataProvider._colorGenerator = colorGenerator;
     }
     return Profiler.ProfileFlameChartDataProvider._colorGenerator;
   }
 
@@ skipping 26 matching lines @@
   /**
    * @override
    * @return {number}
    */
   maxStackDepth() {
     return this._maxStackDepth;
   }
 
   /**
    * @override
-   * @return {?UI.FlameChart.TimelineData}
+   * @return {?PerfUI.FlameChart.TimelineData}
    */
   timelineData() {
     return this._timelineData || this._calculateTimelineData();
   }
 
   /**
-   * @return {!UI.FlameChart.TimelineData}
+   * @return {!PerfUI.FlameChart.TimelineData}
    */
   _calculateTimelineData() {
     throw 'Not implemented.';
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {?Element}
    */
@@ skipping 81 matching lines @@
 };
 
 
 /**
  * @implements {UI.Searchable}
  * @unrestricted
  */
 Profiler.CPUProfileFlameChart = class extends UI.VBox {
   /**
    * @param {!UI.SearchableView} searchableView
-   * @param {!UI.FlameChartDataProvider} dataProvider
+   * @param {!PerfUI.FlameChartDataProvider} dataProvider
    */
   constructor(searchableView, dataProvider) {
     super();
     this.element.id = 'cpu-flame-chart';
 
     this._searchableView = searchableView;
     this._overviewPane = new Profiler.CPUProfileFlameChart.OverviewPane(dataProvider);
     this._overviewPane.show(this.element);
 
-    this._mainPane = new UI.FlameChart(dataProvider, this._overviewPane);
+    this._mainPane = new PerfUI.FlameChart(dataProvider, this._overviewPane);
     this._mainPane.setBarHeight(15);
     this._mainPane.setTextBaseline(4);
     this._mainPane.setTextPadding(2);
     this._mainPane.show(this.element);
-    this._mainPane.addEventListener(UI.FlameChart.Events.EntrySelected, this._onEntrySelected, this);
-    this._overviewPane.addEventListener(UI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
+    this._mainPane.addEventListener(PerfUI.FlameChart.Events.EntrySelected, this._onEntrySelected, this);
+    this._overviewPane.addEventListener(PerfUI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
     this._dataProvider = dataProvider;
     this._searchResults = [];
   }
 
   /**
    * @override
    */
   focus() {
     this._mainPane.focus();
   }
@@ skipping 12 matching lines @@
    * @param {number} timeRight
    */
   selectRange(timeLeft, timeRight) {
     this._overviewPane._selectRange(timeLeft, timeRight);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onEntrySelected(event) {
-    this.dispatchEventToListeners(UI.FlameChart.Events.EntrySelected, event.data);
+    this.dispatchEventToListeners(PerfUI.FlameChart.Events.EntrySelected, event.data);
   }
 
   update() {
     this._overviewPane.update();
     this._mainPane.update();
   }
 
   /**
    * @override
    * @param {!UI.SearchableView.SearchConfig} searchConfig
@@ skipping 61 matching lines @@
   /**
    * @override
    * @return {boolean}
    */
   supportsRegexSearch() {
     return false;
   }
 };
 
 /**
- * @implements {UI.TimelineGrid.Calculator}
+ * @implements {PerfUI.TimelineGrid.Calculator}
  * @unrestricted
  */
 Profiler.CPUProfileFlameChart.OverviewCalculator = class {
   constructor(dataProvider) {
     this._dataProvider = dataProvider;
   }
 
   /**
    * @override
    * @return {number}
@@ skipping 58 matching lines @@
   /**
    * @override
    * @return {number}
    */
   boundarySpan() {
     return this._maximumBoundaries - this._minimumBoundaries;
   }
 };
 
 /**
- * @implements {UI.FlameChartDelegate}
+ * @implements {PerfUI.FlameChartDelegate}
  * @unrestricted
  */
 Profiler.CPUProfileFlameChart.OverviewPane = class extends UI.VBox {
   /**
-   * @param {!UI.FlameChartDataProvider} dataProvider
+   * @param {!PerfUI.FlameChartDataProvider} dataProvider
    */
   constructor(dataProvider) {
     super();
     this.element.classList.add('cpu-profile-flame-chart-overview-pane');
     this._overviewContainer = this.element.createChild('div', 'cpu-profile-flame-chart-overview-container');
-    this._overviewGrid = new UI.OverviewGrid('cpu-profile-flame-chart');
+    this._overviewGrid = new PerfUI.OverviewGrid('cpu-profile-flame-chart');
     this._overviewGrid.element.classList.add('fill');
     this._overviewCanvas = this._overviewContainer.createChild('canvas', 'cpu-profile-flame-chart-overview-canvas');
     this._overviewContainer.appendChild(this._overviewGrid.element);
     this._overviewCalculator = new Profiler.CPUProfileFlameChart.OverviewCalculator(dataProvider);
     this._dataProvider = dataProvider;
-    this._overviewGrid.addEventListener(UI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
+    this._overviewGrid.addEventListener(PerfUI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
   }
 
   /**
    * @override
    * @param {number} windowStartTime
    * @param {number} windowEndTime
    */
   requestWindowTimes(windowStartTime, windowEndTime) {
     this._selectRange(windowStartTime, windowEndTime);
   }
@@ skipping 19 matching lines @@
   /**
    * @param {!Common.Event} event
    */
   _onWindowChanged(event) {
     var startTime = this._dataProvider.minimumBoundary();
     var totalTime = this._dataProvider.totalTime();
     var data = {
       windowTimeLeft: startTime + this._overviewGrid.windowLeft() * totalTime,
       windowTimeRight: startTime + this._overviewGrid.windowRight() * totalTime
     };
-    this.dispatchEventToListeners(UI.OverviewGrid.Events.WindowChanged, data);
+    this.dispatchEventToListeners(PerfUI.OverviewGrid.Events.WindowChanged, data);
   }
 
   /**
-   * @return {?UI.FlameChart.TimelineData}
+   * @return {?PerfUI.FlameChart.TimelineData}
    */
   _timelineData() {
     return this._dataProvider.timelineData();
   }
 
   /**
    * @override
    */
   onResize() {
     this._scheduleUpdate();
   }
 
   _scheduleUpdate() {
     if (this._updateTimerId)
       return;
     this._updateTimerId = this.element.window().requestAnimationFrame(this.update.bind(this));
   }
 
   update() {
     this._updateTimerId = 0;
     var timelineData = this._timelineData();
     if (!timelineData)
       return;
     this._resetCanvas(
-        this._overviewContainer.clientWidth, this._overviewContainer.clientHeight - UI.FlameChart.HeaderHeight);
+        this._overviewContainer.clientWidth, this._overviewContainer.clientHeight - PerfUI.FlameChart.HeaderHeight);
     this._overviewCalculator._updateBoundaries(this);
     this._overviewGrid.updateDividers(this._overviewCalculator);
     this._drawOverviewCanvas();
   }
 
   _drawOverviewCanvas() {
     var canvasWidth = this._overviewCanvas.width;
     var canvasHeight = this._overviewCanvas.height;
     var drawData = this._calculateDrawData(canvasWidth);
     var context = this._overviewCanvas.getContext('2d');
@@ skipping 50 matching lines @@
    * @param {number} height
    */
   _resetCanvas(width, height) {
     var ratio = window.devicePixelRatio;
     this._overviewCanvas.width = width * ratio;
     this._overviewCanvas.height = height * ratio;
     this._overviewCanvas.style.width = width + 'px';
     this._overviewCanvas.style.height = height + 'px';
   }
 };