DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/layer_viewer/PaintProfilerView.js

 /*
  * Copyright (C) 2013 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 13 matching lines @@
  * 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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.PaintProfilerView = class extends WebInspector.HBox {
+LayerViewer.PaintProfilerView = class extends UI.HBox {
   /**
    * @param {function(string=)} showImageCallback
    */
   constructor(showImageCallback) {
     super(true);
     this.registerRequiredCSS('layer_viewer/paintProfiler.css');
     this.contentElement.classList.add('paint-profiler-overview');
     this._canvasContainer = this.contentElement.createChild('div', 'paint-profiler-canvas-container');
     this._progressBanner = this.contentElement.createChild('div', 'full-widget-dimmed-banner hidden');
-    this._progressBanner.textContent = WebInspector.UIString('Profiling\u2026');
-    this._pieChart = new WebInspector.PieChart(55, this._formatPieChartTime.bind(this), true);
+    this._progressBanner.textContent = Common.UIString('Profiling\u2026');
+    this._pieChart = new UI.PieChart(55, this._formatPieChartTime.bind(this), true);
     this._pieChart.element.classList.add('paint-profiler-pie-chart');
     this.contentElement.appendChild(this._pieChart.element);
 
     this._showImageCallback = showImageCallback;
 
     this._canvas = this._canvasContainer.createChild('canvas', 'fill');
     this._context = this._canvas.getContext('2d');
-    this._selectionWindow = new WebInspector.OverviewGrid.Window(this._canvasContainer);
-    this._selectionWindow.addEventListener(WebInspector.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
+    this._selectionWindow = new UI.OverviewGrid.Window(this._canvasContainer);
+    this._selectionWindow.addEventListener(UI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
 
     this._innerBarWidth = 4 * window.devicePixelRatio;
     this._minBarHeight = window.devicePixelRatio;
     this._barPaddingWidth = 2 * window.devicePixelRatio;
     this._outerBarWidth = this._innerBarWidth + this._barPaddingWidth;
     this._pendingScale = 1;
     this._scale = this._pendingScale;
 
     this._reset();
   }
 
   /**
-   * @return {!Object.<string, !WebInspector.PaintProfilerCategory>}
+   * @return {!Object.<string, !LayerViewer.PaintProfilerCategory>}
    */
   static categories() {
-    if (WebInspector.PaintProfilerView._categories)
-      return WebInspector.PaintProfilerView._categories;
-    WebInspector.PaintProfilerView._categories = {
-      shapes: new WebInspector.PaintProfilerCategory('shapes', WebInspector.UIString('Shapes'), 'rgb(255, 161, 129)'),
-      bitmap: new WebInspector.PaintProfilerCategory('bitmap', WebInspector.UIString('Bitmap'), 'rgb(136, 196, 255)'),
-      text: new WebInspector.PaintProfilerCategory('text', WebInspector.UIString('Text'), 'rgb(180, 255, 137)'),
-      misc: new WebInspector.PaintProfilerCategory('misc', WebInspector.UIString('Misc'), 'rgb(206, 160, 255)')
+    if (LayerViewer.PaintProfilerView._categories)
+      return LayerViewer.PaintProfilerView._categories;
+    LayerViewer.PaintProfilerView._categories = {
+      shapes: new LayerViewer.PaintProfilerCategory('shapes', Common.UIString('Shapes'), 'rgb(255, 161, 129)'),
+      bitmap: new LayerViewer.PaintProfilerCategory('bitmap', Common.UIString('Bitmap'), 'rgb(136, 196, 255)'),
+      text: new LayerViewer.PaintProfilerCategory('text', Common.UIString('Text'), 'rgb(180, 255, 137)'),
+      misc: new LayerViewer.PaintProfilerCategory('misc', Common.UIString('Misc'), 'rgb(206, 160, 255)')
     };
-    return WebInspector.PaintProfilerView._categories;
+    return LayerViewer.PaintProfilerView._categories;
   }
 
   /**
-   * @return {!Object.<string, !WebInspector.PaintProfilerCategory>}
+   * @return {!Object.<string, !LayerViewer.PaintProfilerCategory>}
    */
   static _initLogItemCategories() {
-    if (WebInspector.PaintProfilerView._logItemCategoriesMap)
-      return WebInspector.PaintProfilerView._logItemCategoriesMap;
+    if (LayerViewer.PaintProfilerView._logItemCategoriesMap)
+      return LayerViewer.PaintProfilerView._logItemCategoriesMap;
 
-    var categories = WebInspector.PaintProfilerView.categories();
+    var categories = LayerViewer.PaintProfilerView.categories();
 
     var logItemCategories = {};
     logItemCategories['Clear'] = categories['misc'];
     logItemCategories['DrawPaint'] = categories['misc'];
     logItemCategories['DrawData'] = categories['misc'];
     logItemCategories['SetMatrix'] = categories['misc'];
     logItemCategories['PushCull'] = categories['misc'];
     logItemCategories['PopCull'] = categories['misc'];
     logItemCategories['Translate'] = categories['misc'];
     logItemCategories['Scale'] = categories['misc'];
@@ skipping 19 matching lines @@
     logItemCategories['DrawBitmapRectToRect'] = categories['bitmap'];
     logItemCategories['DrawBitmapMatrix'] = categories['bitmap'];
     logItemCategories['DrawBitmapNine'] = categories['bitmap'];
     logItemCategories['DrawSprite'] = categories['bitmap'];
     logItemCategories['DrawPicture'] = categories['bitmap'];
     logItemCategories['DrawText'] = categories['text'];
     logItemCategories['DrawPosText'] = categories['text'];
     logItemCategories['DrawPosTextH'] = categories['text'];
     logItemCategories['DrawTextOnPath'] = categories['text'];
 
-    WebInspector.PaintProfilerView._logItemCategoriesMap = logItemCategories;
+    LayerViewer.PaintProfilerView._logItemCategoriesMap = logItemCategories;
     return logItemCategories;
   }
 
   /**
    * @param {!Object} logItem
-   * @return {!WebInspector.PaintProfilerCategory}
+   * @return {!LayerViewer.PaintProfilerCategory}
    */
   static _categoryForLogItem(logItem) {
     var method = logItem.method.toTitleCase();
 
-    var logItemCategories = WebInspector.PaintProfilerView._initLogItemCategories();
+    var logItemCategories = LayerViewer.PaintProfilerView._initLogItemCategories();
     var result = logItemCategories[method];
     if (!result) {
-      result = WebInspector.PaintProfilerView.categories()['misc'];
+      result = LayerViewer.PaintProfilerView.categories()['misc'];
       logItemCategories[method] = result;
     }
     return result;
   }
 
   /**
    * @override
    */
   onResize() {
     this._update();
   }
 
   /**
-   * @param {?WebInspector.PaintProfilerSnapshot} snapshot
-   * @param {!Array.<!WebInspector.PaintProfilerLogItem>} log
+   * @param {?SDK.PaintProfilerSnapshot} snapshot
+   * @param {!Array.<!SDK.PaintProfilerLogItem>} log
    * @param {?Protocol.DOM.Rect} clipRect
    */
   setSnapshotAndLog(snapshot, log, clipRect) {
     this._reset();
     this._snapshot = snapshot;
     if (this._snapshot)
       this._snapshot.addReference();
     this._log = log;
-    this._logCategories = this._log.map(WebInspector.PaintProfilerView._categoryForLogItem);
+    this._logCategories = this._log.map(LayerViewer.PaintProfilerView._categoryForLogItem);
 
     if (!this._snapshot) {
       this._update();
       this._pieChart.setTotal(0);
       this._selectionWindow.setEnabled(false);
       return;
     }
     this._selectionWindow.setEnabled(true);
     this._progressBanner.classList.remove('hidden');
     this._updateImage();
     snapshot.profile(clipRect, onProfileDone.bind(this));
     /**
      * @param {!Array.<!Protocol.LayerTree.PaintProfile>=} profiles
-     * @this {WebInspector.PaintProfilerView}
+     * @this {LayerViewer.PaintProfilerView}
      */
     function onProfileDone(profiles) {
       this._progressBanner.classList.add('hidden');
       this._profiles = profiles;
       this._update();
       this._updatePieChart();
     }
   }
 
   /**
@@ skipping 56 matching lines @@
         barHeightByCategory[i][categoryName] *= (barTimes[i] * scale + this._minBarHeight) / barTimes[i];
       this._renderBar(i, barHeightByCategory[i]);
     }
   }
 
   /**
    * @param {number} index
    * @param {!Object.<string, number>} heightByCategory
    */
   _renderBar(index, heightByCategory) {
-    var categories = WebInspector.PaintProfilerView.categories();
+    var categories = LayerViewer.PaintProfilerView.categories();
     var currentHeight = 0;
     var x = this._barPaddingWidth + index * this._outerBarWidth;
     for (var categoryName in categories) {
       if (!heightByCategory[categoryName])
         continue;
       currentHeight += heightByCategory[categoryName];
       var y = this._canvas.height - currentHeight;
       this._context.fillStyle = categories[categoryName].color;
       this._context.fillRect(x, y, this._innerBarWidth, heightByCategory[categoryName]);
     }
   }
 
   _onWindowChanged() {
-    this.dispatchEventToListeners(WebInspector.PaintProfilerView.Events.WindowChanged);
+    this.dispatchEventToListeners(LayerViewer.PaintProfilerView.Events.WindowChanged);
     this._updatePieChart();
     if (this._updateImageTimer)
       return;
     this._updateImageTimer = setTimeout(this._updateImage.bind(this), 100);
   }
 
   _updatePieChart() {
     var window = this.selectionWindow();
     if (!this._profiles || !this._profiles.length || !window)
       return;
     var totalTime = 0;
     var timeByCategory = {};
     for (var i = window.left; i < window.right; ++i) {
       var logEntry = this._log[i];
-      var category = WebInspector.PaintProfilerView._categoryForLogItem(logEntry);
+      var category = LayerViewer.PaintProfilerView._categoryForLogItem(logEntry);
       timeByCategory[category.color] = timeByCategory[category.color] || 0;
       for (var j = 0; j < this._profiles.length; ++j) {
         var time = this._profiles[j][logEntry.commandIndex];
         totalTime += time;
         timeByCategory[category.color] += time;
       }
     }
     this._pieChart.setTotal(totalTime / this._profiles.length);
     for (var color in timeByCategory)
       this._pieChart.addSlice(timeByCategory[color] / this._profiles.length, color);
@@ skipping 46 matching lines @@
     if (this._snapshot)
       this._snapshot.release();
     this._snapshot = null;
     this._profiles = null;
     this._selectionWindow.reset();
     this._selectionWindow.setEnabled(false);
   }
 };
 
 /** @enum {symbol} */
-WebInspector.PaintProfilerView.Events = {
+LayerViewer.PaintProfilerView.Events = {
   WindowChanged: Symbol('WindowChanged')
 };
 
 /**
  * @unrestricted
  */
-WebInspector.PaintProfilerCommandLogView = class extends WebInspector.ThrottledWidget {
+LayerViewer.PaintProfilerCommandLogView = class extends UI.ThrottledWidget {
   constructor() {
     super();
     this.setMinimumSize(100, 25);
     this.element.classList.add('overflow-auto');
 
     this._treeOutline = new TreeOutlineInShadow();
     this.element.appendChild(this._treeOutline.element);
 
     this._log = [];
   }
 
   /**
-   * @param {?WebInspector.Target} target
-   * @param {!Array.<!WebInspector.PaintProfilerLogItem>} log
+   * @param {?SDK.Target} target
+   * @param {!Array.<!SDK.PaintProfilerLogItem>} log
    */
   setCommandLog(target, log) {
     this._target = target;
     this._log = log;
-    /** @type {!Map<!WebInspector.PaintProfilerLogItem>} */
+    /** @type {!Map<!SDK.PaintProfilerLogItem>} */
     this._treeItemCache = new Map();
     this.updateWindow({left: 0, right: this._log.length});
   }
 
   /**
-   * @param {!WebInspector.PaintProfilerLogItem} logItem
+   * @param {!SDK.PaintProfilerLogItem} logItem
    */
   _appendLogItem(logItem) {
     var treeElement = this._treeItemCache.get(logItem);
     if (!treeElement) {
-      treeElement = new WebInspector.LogTreeElement(this, logItem);
+      treeElement = new LayerViewer.LogTreeElement(this, logItem);
       this._treeItemCache.set(logItem, treeElement);
     } else if (treeElement.parent) {
       return;
     }
     this._treeOutline.appendChild(treeElement);
   }
 
   /**
    * @param {?{left: number, right: number}} selectionWindow
    */
@@ skipping 26 matching lines @@
     }
     for (var i = this._selectionWindow.left, right = this._selectionWindow.right; i < right; ++i)
       this._appendLogItem(this._log[i]);
     return Promise.resolve();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.LogTreeElement = class extends TreeElement {
+LayerViewer.LogTreeElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.PaintProfilerCommandLogView} ownerView
-   * @param {!WebInspector.PaintProfilerLogItem} logItem
+   * @param {!LayerViewer.PaintProfilerCommandLogView} ownerView
+   * @param {!SDK.PaintProfilerLogItem} logItem
    */
   constructor(ownerView, logItem) {
     super('', !!logItem.params);
     this._logItem = logItem;
     this._ownerView = ownerView;
     this._filled = false;
   }
 
   /**
    * @override
    */
   onattach() {
     this._update();
   }
 
   /**
    * @override
    */
   onpopulate() {
     for (var param in this._logItem.params)
-      WebInspector.LogPropertyTreeElement._appendLogPropertyItem(this, param, this._logItem.params[param]);
+      LayerViewer.LogPropertyTreeElement._appendLogPropertyItem(this, param, this._logItem.params[param]);
   }
 
   /**
    * @param {*} param
    * @param {string} name
    * @return {string}
    */
   _paramToString(param, name) {
     if (typeof param !== 'object')
       return typeof param === 'string' && param.length > 100 ? name : JSON.stringify(param);
@@ skipping 27 matching lines @@
   _update() {
     var title = createDocumentFragment();
     title.createTextChild(this._logItem.method + '(' + this._paramsToString(this._logItem.params) + ')');
     this.title = title;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.LogPropertyTreeElement = class extends TreeElement {
+LayerViewer.LogPropertyTreeElement = class extends TreeElement {
   /**
    * @param {!{name: string, value}} property
    */
   constructor(property) {
     super();
     this._property = property;
   }
 
   /**
    * @param {!TreeElement} element
    * @param {string} name
    * @param {*} value
    */
   static _appendLogPropertyItem(element, name, value) {
-    var treeElement = new WebInspector.LogPropertyTreeElement({name: name, value: value});
+    var treeElement = new LayerViewer.LogPropertyTreeElement({name: name, value: value});
     element.appendChild(treeElement);
     if (value && typeof value === 'object') {
       for (var property in value)
-        WebInspector.LogPropertyTreeElement._appendLogPropertyItem(treeElement, property, value[property]);
+        LayerViewer.LogPropertyTreeElement._appendLogPropertyItem(treeElement, property, value[property]);
     }
   }
 
   /**
    * @override
    */
   onattach() {
     var title = createDocumentFragment();
     var nameElement = title.createChild('span', 'name');
     nameElement.textContent = this._property.name;
     var separatorElement = title.createChild('span', 'separator');
     separatorElement.textContent = ': ';
     if (this._property.value === null || typeof this._property.value !== 'object') {
       var valueElement = title.createChild('span', 'value');
       valueElement.textContent = JSON.stringify(this._property.value);
       valueElement.classList.add('cm-js-' + (this._property.value === null ? 'null' : typeof this._property.value));
     }
     this.title = title;
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.PaintProfilerCategory = class {
+LayerViewer.PaintProfilerCategory = class {
   /**
    * @param {string} name
    * @param {string} title
    * @param {string} color
    */
   constructor(name, title, color) {
     this.name = name;
     this.title = title;
     this.color = color;
   }
 };