DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/elements/MetricsSidebarPane.js

 /*
  * Copyright (C) 2007 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * (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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.MetricsSidebarPane = class extends WebInspector.ElementsSidebarPane {
+Elements.MetricsSidebarPane = class extends Elements.ElementsSidebarPane {
   constructor() {
     super();
   }
 
   /**
    * @override
    * @protected
    * @return {!Promise.<?>}
    */
   doUpdate() {
     // "style" attribute might have changed. Update metrics unless they are being edited
     // (if a CSS property is added, a StyleSheetChanged event is dispatched).
     if (this._isEditingMetrics)
       return Promise.resolve();
 
     // FIXME: avoid updates of a collapsed pane.
     var node = this.node();
     var cssModel = this.cssModel();
     if (!node || node.nodeType() !== Node.ELEMENT_NODE || !cssModel) {
       this.element.removeChildren();
       return Promise.resolve();
     }
 
     /**
      * @param {?Map.<string, string>} style
-     * @this {WebInspector.MetricsSidebarPane}
+     * @this {Elements.MetricsSidebarPane}
      */
     function callback(style) {
       if (!style || this.node() !== node)
         return;
       this._updateMetrics(style);
     }
     /**
-     * @param {?WebInspector.CSSModel.InlineStyleResult} inlineStyleResult
-     * @this {WebInspector.MetricsSidebarPane}
+     * @param {?SDK.CSSModel.InlineStyleResult} inlineStyleResult
+     * @this {Elements.MetricsSidebarPane}
      */
     function inlineStyleCallback(inlineStyleResult) {
       if (inlineStyleResult && this.node() === node)
         this.inlineStyle = inlineStyleResult.inlineStyle;
     }
 
     var promises = [
       cssModel.computedStylePromise(node.id).then(callback.bind(this)),
       cssModel.inlineStylesPromise(node.id).then(inlineStyleCallback.bind(this))
     ];
@@ skipping 36 matching lines @@
    */
   _highlightDOMNode(showHighlight, mode, event) {
     event.consume();
     if (showHighlight && this.node()) {
       if (this._highlightMode === mode)
         return;
       this._highlightMode = mode;
       this.node().highlight(mode);
     } else {
       delete this._highlightMode;
-      WebInspector.DOMModel.hideDOMNodeHighlight();
+      SDK.DOMModel.hideDOMNodeHighlight();
     }
 
     for (var i = 0; this._boxElements && i < this._boxElements.length; ++i) {
       var element = this._boxElements[i];
       if (!this.node() || mode === 'all' || element._name === mode)
         element.style.backgroundColor = element._backgroundColor;
       else
         element.style.backgroundColor = '';
     }
   }
 
   /**
    * @param {!Map.<string, string>} style
    */
   _updateMetrics(style) {
     // Updating with computed style.
     var metricsElement = createElement('div');
     metricsElement.className = 'metrics';
     var self = this;
 
     /**
      * @param {!Map.<string, string>} style
      * @param {string} name
      * @param {string} side
      * @param {string} suffix
-     * @this {WebInspector.MetricsSidebarPane}
+     * @this {Elements.MetricsSidebarPane}
      */
     function createBoxPartElement(style, name, side, suffix) {
       var propertyName = (name !== 'position' ? name + '-' : '') + side + suffix;
       var value = style.get(propertyName);
       if (value === '' || (name !== 'position' && value === '0px'))
         value = '\u2012';
       else if (name === 'position' && value === 'auto')
         value = '\u2012';
       value = value.replace(/px$/, '');
       value = Number.toFixedIfFloating(value);
@@ skipping 56 matching lines @@
       'table-header-group': true,
       'table-row': true,
       'table-row-group': true
     };
 
     // Position types for which top, left, bottom and right are ignored.
     var noPositionType = {'static': true};
 
     var boxes = ['content', 'padding', 'border', 'margin', 'position'];
     var boxColors = [
-      WebInspector.Color.PageHighlight.Content, WebInspector.Color.PageHighlight.Padding,
-      WebInspector.Color.PageHighlight.Border, WebInspector.Color.PageHighlight.Margin,
-      WebInspector.Color.fromRGBA([0, 0, 0, 0])
+      Common.Color.PageHighlight.Content, Common.Color.PageHighlight.Padding,
+      Common.Color.PageHighlight.Border, Common.Color.PageHighlight.Margin,
+      Common.Color.fromRGBA([0, 0, 0, 0])
     ];
     var boxLabels = [
-      WebInspector.UIString('content'), WebInspector.UIString('padding'), WebInspector.UIString('border'),
-      WebInspector.UIString('margin'), WebInspector.UIString('position')
+      Common.UIString('content'), Common.UIString('padding'), Common.UIString('border'),
+      Common.UIString('margin'), Common.UIString('position')
     ];
     var previousBox = null;
     this._boxElements = [];
     for (var i = 0; i < boxes.length; ++i) {
       var name = boxes[i];
 
       if (name === 'margin' && noMarginDisplayType[style.get('display')])
         continue;
       if (name === 'padding' && noPaddingDisplayType[style.get('display')])
         continue;
       if (name === 'position' && noPositionType[style.get('position')])
         continue;
 
       var boxElement = createElement('div');
       boxElement.className = name;
-      boxElement._backgroundColor = boxColors[i].asString(WebInspector.Color.Format.RGBA);
+      boxElement._backgroundColor = boxColors[i].asString(Common.Color.Format.RGBA);
       boxElement._name = name;
       boxElement.style.backgroundColor = boxElement._backgroundColor;
       boxElement.addEventListener(
           'mouseover', this._highlightDOMNode.bind(this, true, name === 'position' ? 'all' : name), false);
       this._boxElements.push(boxElement);
 
       if (name === 'content') {
         var widthElement = createElement('span');
         widthElement.textContent = getContentAreaWidthPx(style);
         widthElement.addEventListener(
@@ skipping 36 matching lines @@
     this.element.appendChild(metricsElement);
   }
 
   /**
    * @param {!Element} targetElement
    * @param {string} box
    * @param {string} styleProperty
    * @param {!Map.<string, string>} computedStyle
    */
   startEditing(targetElement, box, styleProperty, computedStyle) {
-    if (WebInspector.isBeingEdited(targetElement))
+    if (UI.isBeingEdited(targetElement))
       return;
 
     var context = {box: box, styleProperty: styleProperty, computedStyle: computedStyle};
     var boundKeyDown = this._handleKeyDown.bind(this, context, styleProperty);
     context.keyDownHandler = boundKeyDown;
     targetElement.addEventListener('keydown', boundKeyDown, false);
 
     this._isEditingMetrics = true;
 
-    var config = new WebInspector.InplaceEditor.Config(
+    var config = new UI.InplaceEditor.Config(
         this._editingCommitted.bind(this), this.editingCancelled.bind(this), context);
-    WebInspector.InplaceEditor.startEditing(targetElement, config);
+    UI.InplaceEditor.startEditing(targetElement, config);
 
     targetElement.getComponentSelection().setBaseAndExtent(targetElement, 0, targetElement, 1);
   }
 
   _handleKeyDown(context, styleProperty, event) {
     var element = event.currentTarget;
 
     /**
      * @param {string} originalValue
      * @param {string} replacementString
-     * @this {WebInspector.MetricsSidebarPane}
+     * @this {Elements.MetricsSidebarPane}
      */
     function finishHandler(originalValue, replacementString) {
       this._applyUserInput(element, replacementString, originalValue, context, false);
     }
 
     /**
      * @param {string} prefix
      * @param {number} number
      * @param {string} suffix
      * @return {string}
      */
     function customNumberHandler(prefix, number, suffix) {
       if (styleProperty !== 'margin' && number < 0)
         number = 0;
       return prefix + number + suffix;
     }
 
-    WebInspector.handleElementValueModifications(
+    UI.handleElementValueModifications(
         event, element, finishHandler.bind(this), undefined, customNumberHandler);
   }
 
   editingEnded(element, context) {
     delete this.originalPropertyData;
     delete this.previousPropertyDataCandidate;
     element.removeEventListener('keydown', context.keyDownHandler, false);
     delete this._isEditingMetrics;
   }
 
@@ skipping 29 matching lines @@
     userInput = userInput.toLowerCase();
     // Append a "px" unit if the user input was just a number.
     if (/^\d+$/.test(userInput))
       userInput += 'px';
 
     var styleProperty = context.styleProperty;
     var computedStyle = context.computedStyle;
 
     if (computedStyle.get('box-sizing') === 'border-box' && (styleProperty === 'width' || styleProperty === 'height')) {
       if (!userInput.match(/px$/)) {
-        WebInspector.console.error(
+        Common.console.error(
             'For elements with box-sizing: border-box, only absolute content area dimensions can be applied');
         return;
       }
 
       var borderBox = this._getBox(computedStyle, 'border');
       var paddingBox = this._getBox(computedStyle, 'padding');
       var userValuePx = Number(userInput.replace(/px$/, ''));
       if (isNaN(userValuePx))
         return;
       if (styleProperty === 'width')
@@ skipping 14 matching lines @@
 
       this.previousPropertyDataCandidate = property;
       property.setValue(userInput, commitEditor, true, callback.bind(this));
       return;
     }
 
     this.inlineStyle.appendProperty(context.styleProperty, userInput, callback.bind(this));
 
     /**
      * @param {boolean} success
-     * @this {WebInspector.MetricsSidebarPane}
+     * @this {Elements.MetricsSidebarPane}
      */
     function callback(success) {
       if (!success)
         return;
       if (!('originalPropertyData' in this))
         this.originalPropertyData = this.previousPropertyDataCandidate;
 
       if (typeof this._highlightMode !== 'undefined')
         this.node().highlight(this._highlightMode);
 
       if (commitEditor)
         this.update();
     }
   }
 
   _editingCommitted(element, userInput, previousContent, context) {
     this.editingEnded(element, context);
     this._applyUserInput(element, userInput, previousContent, context, true);
   }
 };