DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2012 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * 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.TimelineModeView}
+ * @implements {Timeline.TimelineModeView}
  * @unrestricted
  */
-WebInspector.CountersGraph = class extends WebInspector.VBox {
+Timeline.CountersGraph = class extends UI.VBox {
   /**
-   * @param {!WebInspector.TimelineModeViewDelegate} delegate
-   * @param {!WebInspector.TimelineModel} model
-   * @param {!Array<!WebInspector.TimelineModel.Filter>} filters
+   * @param {!Timeline.TimelineModeViewDelegate} delegate
+   * @param {!TimelineModel.TimelineModel} model
+   * @param {!Array<!TimelineModel.TimelineModel.Filter>} filters
    */
   constructor(delegate, model, filters) {
     super();
 
     this.element.id = 'memory-graphs-container';
 
     this._delegate = delegate;
     this._model = model;
     this._filters = filters;
-    this._calculator = new WebInspector.CounterGraphCalculator(this._model);
+    this._calculator = new Timeline.CounterGraphCalculator(this._model);
 
     // Create selectors
-    this._infoWidget = new WebInspector.HBox();
+    this._infoWidget = new UI.HBox();
     this._infoWidget.element.classList.add('memory-counter-selector-swatches', 'timeline-toolbar-resizer');
     this._infoWidget.show(this.element);
 
-    this._graphsContainer = new WebInspector.VBox();
+    this._graphsContainer = new UI.VBox();
     this._graphsContainer.show(this.element);
-    var canvasWidget = new WebInspector.VBoxWithResizeCallback(this._resize.bind(this));
+    var canvasWidget = new UI.VBoxWithResizeCallback(this._resize.bind(this));
     canvasWidget.show(this._graphsContainer.element);
     this._createCurrentValuesBar();
     this._canvasContainer = canvasWidget.element;
     this._canvasContainer.id = 'memory-graphs-canvas-container';
     this._canvas = this._canvasContainer.createChild('canvas');
     this._canvas.id = 'memory-counters-graph';
 
     this._canvasContainer.addEventListener('mouseover', this._onMouseMove.bind(this), true);
     this._canvasContainer.addEventListener('mousemove', this._onMouseMove.bind(this), true);
     this._canvasContainer.addEventListener('mouseleave', this._onMouseLeave.bind(this), true);
     this._canvasContainer.addEventListener('click', this._onClick.bind(this), true);
     // We create extra timeline grid here to reuse its event dividers.
-    this._timelineGrid = new WebInspector.TimelineGrid();
+    this._timelineGrid = new UI.TimelineGrid();
     this._canvasContainer.appendChild(this._timelineGrid.dividersElement);
 
     this._counters = [];
     this._counterUI = [];
   }
 
   _createCurrentValuesBar() {
     this._currentValuesBar = this._graphsContainer.element.createChild('div');
     this._currentValuesBar.id = 'counter-values-bar';
   }
 
   /**
    * @param {string} uiName
    * @param {string} uiValueTemplate
    * @param {string} color
    * @param {function(number):string=} formatter
-   * @return {!WebInspector.CountersGraph.Counter}
+   * @return {!Timeline.CountersGraph.Counter}
    */
   createCounter(uiName, uiValueTemplate, color, formatter) {
-    var counter = new WebInspector.CountersGraph.Counter();
+    var counter = new Timeline.CountersGraph.Counter();
     this._counters.push(counter);
     this._counterUI.push(
-        new WebInspector.CountersGraph.CounterUI(this, uiName, uiValueTemplate, color, counter, formatter));
+        new Timeline.CountersGraph.CounterUI(this, uiName, uiValueTemplate, color, counter, formatter));
     return counter;
   }
 
   /**
    * @override
-   * @return {!WebInspector.Widget}
+   * @return {!UI.Widget}
    */
   view() {
     return this;
   }
 
   /**
    * @override
    */
   dispose() {
   }
@@ skipping 30 matching lines @@
    * @override
    * @param {number} startTime
    * @param {number} endTime
    */
   setWindowTimes(startTime, endTime) {
     this._calculator.setWindow(startTime, endTime);
     this.scheduleRefresh();
   }
 
   scheduleRefresh() {
-    WebInspector.invokeOnceAfterBatchUpdate(this, this.refresh);
+    UI.invokeOnceAfterBatchUpdate(this, this.refresh);
   }
 
   draw() {
     for (var i = 0; i < this._counters.length; ++i) {
       this._counters[i]._calculateVisibleIndexes(this._calculator);
       this._counters[i]._calculateXValues(this._canvas.width);
     }
     this._clear();
 
     for (var i = 0; i < this._counterUI.length; i++)
@@ skipping 63 matching lines @@
   refreshRecords() {
   }
 
   _clear() {
     var ctx = this._canvas.getContext('2d');
     ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
   }
 
   /**
    * @override
-   * @param {?WebInspector.TracingModel.Event} event
+   * @param {?SDK.TracingModel.Event} event
    * @param {string=} regex
    * @param {boolean=} select
    */
   highlightSearchResult(event, regex, select) {
   }
 
   /**
    * @override
-   * @param {?WebInspector.TracingModel.Event} event
+   * @param {?SDK.TracingModel.Event} event
    */
   highlightEvent(event) {
   }
 
   /**
    * @override
-   * @param {?WebInspector.TimelineSelection} selection
+   * @param {?Timeline.TimelineSelection} selection
    */
   setSelection(selection) {
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.CountersGraph.Counter = class {
+Timeline.CountersGraph.Counter = class {
   constructor() {
     this.times = [];
     this.values = [];
   }
 
   /**
    * @param {number} time
    * @param {number} value
    */
   appendSample(time, value) {
@@ skipping 32 matching lines @@
     maxValue = maxValue || 1;
     if (this._limitValue) {
       if (maxValue > this._limitValue * 0.5)
         maxValue = Math.max(maxValue, this._limitValue);
       minValue = Math.min(minValue, this._limitValue);
     }
     return {min: minValue, max: maxValue};
   }
 
   /**
-   * @param {!WebInspector.CounterGraphCalculator} calculator
+   * @param {!Timeline.CounterGraphCalculator} calculator
    */
   _calculateVisibleIndexes(calculator) {
     var start = calculator.minimumBoundary();
     var end = calculator.maximumBoundary();
 
     // Maximum index of element whose time <= start.
     this._minimumIndex = Number.constrain(this.times.upperBound(start) - 1, 0, this.times.length - 1);
 
     // Minimum index of element whose time >= end.
     this._maximumIndex = Number.constrain(this.times.lowerBound(end), 0, this.times.length - 1);
@@ skipping 14 matching lines @@
 
     this.x = new Array(this.values.length);
     for (var i = this._minimumIndex + 1; i <= this._maximumIndex; i++)
       this.x[i] = xFactor * (this.times[i] - this._minTime);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.CountersGraph.CounterUI = class {
+Timeline.CountersGraph.CounterUI = class {
   /**
-   * @param {!WebInspector.CountersGraph} memoryCountersPane
+   * @param {!Timeline.CountersGraph} memoryCountersPane
    * @param {string} title
    * @param {string} currentValueLabel
    * @param {string} graphColor
-   * @param {!WebInspector.CountersGraph.Counter} counter
+   * @param {!Timeline.CountersGraph.Counter} counter
    * @param {(function(number): string)|undefined} formatter
    */
   constructor(memoryCountersPane, title, currentValueLabel, graphColor, counter, formatter) {
     this._memoryCountersPane = memoryCountersPane;
     this.counter = counter;
     this._formatter = formatter || Number.withThousandsSeparator;
     var container = memoryCountersPane._infoWidget.element.createChild('div', 'memory-counter-selector-info');
 
-    this._setting = WebInspector.settings.createSetting('timelineCountersGraph-' + title, true);
-    this._filter = new WebInspector.ToolbarCheckbox(title, title, this._setting);
+    this._setting = Common.settings.createSetting('timelineCountersGraph-' + title, true);
+    this._filter = new UI.ToolbarCheckbox(title, title, this._setting);
     this._filter.inputElement.classList.add('-theme-preserve');
-    var color = WebInspector.Color.parse(graphColor).setAlpha(0.5).asString(WebInspector.Color.Format.RGBA);
+    var color = Common.Color.parse(graphColor).setAlpha(0.5).asString(Common.Color.Format.RGBA);
     if (color) {
       this._filter.element.backgroundColor = color;
       this._filter.element.borderColor = 'transparent';
     }
     this._filter.inputElement.addEventListener('click', this._toggleCounterGraph.bind(this));
     container.appendChild(this._filter.element);
     this._range = this._filter.element.createChild('span', 'range');
 
     this._value = memoryCountersPane._currentValuesBar.createChild('span', 'memory-counter-value');
     this._value.style.color = graphColor;
     this.graphColor = graphColor;
-    this.limitColor = WebInspector.Color.parse(graphColor).setAlpha(0.3).asString(WebInspector.Color.Format.RGBA);
+    this.limitColor = Common.Color.parse(graphColor).setAlpha(0.3).asString(Common.Color.Format.RGBA);
     this.graphYValues = [];
     this._verticalPadding = 10;
 
     this._currentValueLabel = currentValueLabel;
     this._marker = memoryCountersPane._canvasContainer.createChild('div', 'memory-counter-marker');
     this._marker.style.backgroundColor = graphColor;
     this._clearCurrentValueAndMarker();
   }
 
   reset() {
     this._range.textContent = '';
   }
 
   /**
    * @param {number} minValue
    * @param {number} maxValue
    */
   setRange(minValue, maxValue) {
     var min = this._formatter(minValue);
     var max = this._formatter(maxValue);
-    this._range.textContent = WebInspector.UIString('[%s\u2009\u2013\u2009%s]', min, max);
+    this._range.textContent = Common.UIString('[%s\u2009\u2013\u2009%s]', min, max);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _toggleCounterGraph(event) {
     this._value.classList.toggle('hidden', !this._filter.checked());
     this._memoryCountersPane.refresh();
   }
 
   /**
    * @param {number} x
    * @return {number}
    */
   _recordIndexAt(x) {
     return this.counter.x.upperBound(
                x * window.devicePixelRatio, null, this.counter._minimumIndex + 1, this.counter._maximumIndex + 1) -
         1;
   }
 
   /**
    * @param {number} x
    */
   updateCurrentValue(x) {
     if (!this.visible() || !this.counter.values.length || !this.counter.x)
       return;
     var index = this._recordIndexAt(x);
     var value = Number.withThousandsSeparator(this.counter.values[index]);
-    this._value.textContent = WebInspector.UIString(this._currentValueLabel, value);
+    this._value.textContent = Common.UIString(this._currentValueLabel, value);
     var y = this.graphYValues[index] / window.devicePixelRatio;
     this._marker.style.left = x + 'px';
     this._marker.style.top = y + 'px';
     this._marker.classList.remove('hidden');
   }
 
   _clearCurrentValueAndMarker() {
     this._value.textContent = '';
     this._marker.classList.add('hidden');
   }
@@ skipping 63 matching lines @@
 
   /**
    * @return {boolean}
    */
   visible() {
     return this._filter.checked();
   }
 };
 
 /**
- * @implements {WebInspector.TimelineGrid.Calculator}
+ * @implements {UI.TimelineGrid.Calculator}
  * @unrestricted
  */
-WebInspector.CounterGraphCalculator = class {
+Timeline.CounterGraphCalculator = class {
   /**
-   * @param {!WebInspector.TimelineModel} model
+   * @param {!TimelineModel.TimelineModel} model
    */
   constructor(model) {
     this._model = model;
   }
 
   /**
    * @override
    * @return {number}
    */
   paddingLeft() {
@@ skipping 13 matching lines @@
     this._minimumBoundary = minimumBoundary;
     this._maximumBoundary = maximumBoundary;
   }
 
   /**
    * @param {number} clientWidth
    * @param {number=} paddingLeft
    */
   setDisplayWindow(clientWidth, paddingLeft) {
     this._paddingLeft = paddingLeft || 0;
-    this._workingArea = clientWidth - WebInspector.CounterGraphCalculator._minWidth - this._paddingLeft;
+    this._workingArea = clientWidth - Timeline.CounterGraphCalculator._minWidth - this._paddingLeft;
   }
 
   /**
    * @override
    * @param {number} value
    * @param {number=} precision
    * @return {string}
    */
   formatValue(value, precision) {
     return Number.preciseMillisToString(value - this.zeroTime(), precision);
@@ skipping 25 matching lines @@
 
   /**
    * @override
    * @return {number}
    */
   boundarySpan() {
     return this._maximumBoundary - this._minimumBoundary;
   }
 };
 
-WebInspector.CounterGraphCalculator._minWidth = 5;
+Timeline.CounterGraphCalculator._minWidth = 5;