DevTools: rename WebInspector into modules.

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 {WebInspector.FlameChartDataProvider}
+ * @implements {UI.FlameChartDataProvider}
  * @unrestricted
  */
-WebInspector.ProfileFlameChartDataProvider = class {
+Profiler.ProfileFlameChartDataProvider = class {
   /**
-   * @param {?WebInspector.Target} target
+   * @param {?SDK.Target} target
    */
   constructor(target) {
-    WebInspector.FlameChartDataProvider.call(this);
+    UI.FlameChartDataProvider.call(this);
     this._target = target;
-    this._colorGenerator = WebInspector.ProfileFlameChartDataProvider.colorGenerator();
+    this._colorGenerator = Profiler.ProfileFlameChartDataProvider.colorGenerator();
   }
 
   /**
-   * @return {!WebInspector.FlameChart.ColorGenerator}
+   * @return {!UI.FlameChart.ColorGenerator}
    */
   static colorGenerator() {
-    if (!WebInspector.ProfileFlameChartDataProvider._colorGenerator) {
-      var colorGenerator = new WebInspector.FlameChart.ColorGenerator(
+    if (!Profiler.ProfileFlameChartDataProvider._colorGenerator) {
+      var colorGenerator = new UI.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%)');
-      WebInspector.ProfileFlameChartDataProvider._colorGenerator = colorGenerator;
+      Profiler.ProfileFlameChartDataProvider._colorGenerator = colorGenerator;
     }
-    return WebInspector.ProfileFlameChartDataProvider._colorGenerator;
+    return Profiler.ProfileFlameChartDataProvider._colorGenerator;
   }
 
   /**
    * @override
    * @return {number}
    */
   barHeight() {
     return 15;
   }
 
@@ skipping 42 matching lines @@
   /**
    * @override
    * @return {number}
    */
   maxStackDepth() {
     return this._maxStackDepth;
   }
 
   /**
    * @override
-   * @return {?WebInspector.FlameChart.TimelineData}
+   * @return {?UI.FlameChart.TimelineData}
    */
   timelineData() {
     return this._timelineData || this._calculateTimelineData();
   }
 
   /**
-   * @return {!WebInspector.FlameChart.TimelineData}
+   * @return {!UI.FlameChart.TimelineData}
    */
   _calculateTimelineData() {
     throw 'Not implemented.';
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {?Element}
    */
@@ skipping 10 matching lines @@
     return this._entryNodes[entryIndex].scriptId !== '0';
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {string}
    */
   entryTitle(entryIndex) {
     var node = this._entryNodes[entryIndex];
-    return WebInspector.beautifyFunctionName(node.functionName);
+    return UI.beautifyFunctionName(node.functionName);
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {?string}
    */
   entryFont(entryIndex) {
     if (!this._font) {
-      this._font = (this.barHeight() - 4) + 'px ' + WebInspector.fontFamily();
+      this._font = (this.barHeight() - 4) + 'px ' + Host.fontFamily();
       this._boldFont = 'bold ' + this._font;
     }
     var node = this._entryNodes[entryIndex];
     return node.deoptReason ? this._boldFont : this._font;
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {string}
@@ skipping 42 matching lines @@
    * @param {number} entryIndex
    * @return {string}
    */
   textColor(entryIndex) {
     return '#333';
   }
 };
 
 
 /**
- * @implements {WebInspector.Searchable}
+ * @implements {UI.Searchable}
  * @unrestricted
  */
-WebInspector.CPUProfileFlameChart = class extends WebInspector.VBox {
+Profiler.CPUProfileFlameChart = class extends UI.VBox {
   /**
-   * @param {!WebInspector.SearchableView} searchableView
-   * @param {!WebInspector.FlameChartDataProvider} dataProvider
+   * @param {!UI.SearchableView} searchableView
+   * @param {!UI.FlameChartDataProvider} dataProvider
    */
   constructor(searchableView, dataProvider) {
     super();
     this.element.id = 'cpu-flame-chart';
 
     this._searchableView = searchableView;
-    this._overviewPane = new WebInspector.CPUProfileFlameChart.OverviewPane(dataProvider);
+    this._overviewPane = new Profiler.CPUProfileFlameChart.OverviewPane(dataProvider);
     this._overviewPane.show(this.element);
 
-    this._mainPane = new WebInspector.FlameChart(dataProvider, this._overviewPane);
+    this._mainPane = new UI.FlameChart(dataProvider, this._overviewPane);
     this._mainPane.show(this.element);
-    this._mainPane.addEventListener(WebInspector.FlameChart.Events.EntrySelected, this._onEntrySelected, this);
-    this._overviewPane.addEventListener(WebInspector.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
+    this._mainPane.addEventListener(UI.FlameChart.Events.EntrySelected, this._onEntrySelected, this);
+    this._overviewPane.addEventListener(UI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
     this._dataProvider = dataProvider;
     this._searchResults = [];
   }
 
   /**
    * @override
    */
   focus() {
     this._mainPane.focus();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _onWindowChanged(event) {
     var windowLeft = event.data.windowTimeLeft;
     var windowRight = event.data.windowTimeRight;
     this._mainPane.setWindowTimes(windowLeft, windowRight);
   }
 
   /**
    * @param {number} timeLeft
    * @param {number} timeRight
    */
   selectRange(timeLeft, timeRight) {
     this._overviewPane._selectRange(timeLeft, timeRight);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _onEntrySelected(event) {
-    this.dispatchEventToListeners(WebInspector.FlameChart.Events.EntrySelected, event.data);
+    this.dispatchEventToListeners(UI.FlameChart.Events.EntrySelected, event.data);
   }
 
   update() {
     this._overviewPane.update();
     this._mainPane.update();
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {boolean} shouldJump
    * @param {boolean=} jumpBackwards
    */
   performSearch(searchConfig, shouldJump, jumpBackwards) {
     var matcher = createPlainTextSearchRegex(searchConfig.query, searchConfig.caseSensitive ? '' : 'i');
 
     var selectedEntryIndex = this._searchResultIndex !== -1 ? this._searchResults[this._searchResultIndex] : -1;
     this._searchResults = [];
     var entriesCount = this._dataProvider._entryNodes.length;
     for (var index = 0; index < entriesCount; ++index) {
@@ skipping 51 matching lines @@
   /**
    * @override
    * @return {boolean}
    */
   supportsRegexSearch() {
     return false;
   }
 };
 
 /**
- * @implements {WebInspector.TimelineGrid.Calculator}
+ * @implements {UI.TimelineGrid.Calculator}
  * @unrestricted
  */
-WebInspector.CPUProfileFlameChart.OverviewCalculator = class {
+Profiler.CPUProfileFlameChart.OverviewCalculator = class {
   constructor(dataProvider) {
     this._dataProvider = dataProvider;
   }
 
   /**
    * @override
    * @return {number}
    */
   paddingLeft() {
     return 0;
   }
 
   /**
-   * @param {!WebInspector.CPUProfileFlameChart.OverviewPane} overviewPane
+   * @param {!Profiler.CPUProfileFlameChart.OverviewPane} overviewPane
    */
   _updateBoundaries(overviewPane) {
     this._minimumBoundaries = overviewPane._dataProvider.minimumBoundary();
     var totalTime = overviewPane._dataProvider.totalTime();
     this._maximumBoundaries = this._minimumBoundaries + totalTime;
     this._xScaleFactor = overviewPane._overviewContainer.clientWidth / totalTime;
   }
 
   /**
    * @override
@@ skipping 41 matching lines @@
   /**
    * @override
    * @return {number}
    */
   boundarySpan() {
     return this._maximumBoundaries - this._minimumBoundaries;
   }
 };
 
 /**
- * @implements {WebInspector.FlameChartDelegate}
+ * @implements {UI.FlameChartDelegate}
  * @unrestricted
  */
-WebInspector.CPUProfileFlameChart.OverviewPane = class extends WebInspector.VBox {
+Profiler.CPUProfileFlameChart.OverviewPane = class extends UI.VBox {
   /**
-   * @param {!WebInspector.FlameChartDataProvider} dataProvider
+   * @param {!UI.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 WebInspector.OverviewGrid('cpu-profile-flame-chart');
+    this._overviewGrid = new UI.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 WebInspector.CPUProfileFlameChart.OverviewCalculator(dataProvider);
+    this._overviewCalculator = new Profiler.CPUProfileFlameChart.OverviewCalculator(dataProvider);
     this._dataProvider = dataProvider;
-    this._overviewGrid.addEventListener(WebInspector.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
+    this._overviewGrid.addEventListener(UI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
   }
 
   /**
    * @override
    * @param {number} windowStartTime
    * @param {number} windowEndTime
    */
   requestWindowTimes(windowStartTime, windowEndTime) {
     this._selectRange(windowStartTime, windowEndTime);
   }
@@ skipping 10 matching lines @@
    * @param {number} timeLeft
    * @param {number} timeRight
    */
   _selectRange(timeLeft, timeRight) {
     var startTime = this._dataProvider.minimumBoundary();
     var totalTime = this._dataProvider.totalTime();
     this._overviewGrid.setWindow((timeLeft - startTime) / totalTime, (timeRight - startTime) / totalTime);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @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(WebInspector.OverviewGrid.Events.WindowChanged, data);
+    this.dispatchEventToListeners(UI.OverviewGrid.Events.WindowChanged, data);
   }
 
   /**
-   * @return {?WebInspector.FlameChart.TimelineData}
+   * @return {?UI.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 - WebInspector.FlameChart.DividersBarHeight);
+        this._overviewContainer.clientHeight - UI.FlameChart.DividersBarHeight);
     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';
   }
 };