DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sdk/CSSProperty.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
-WebInspector.CSSProperty = class {
+SDK.CSSProperty = class {
   /**
-   * @param {!WebInspector.CSSStyleDeclaration} ownerStyle
+   * @param {!SDK.CSSStyleDeclaration} ownerStyle
    * @param {number} index
    * @param {string} name
    * @param {string} value
    * @param {boolean} important
    * @param {boolean} disabled
    * @param {boolean} parsedOk
    * @param {boolean} implicit
    * @param {?string=} text
    * @param {!Protocol.CSS.SourceRange=} range
    */
   constructor(ownerStyle, index, name, value, important, disabled, parsedOk, implicit, text, range) {
     this.ownerStyle = ownerStyle;
     this.index = index;
     this.name = name;
     this.value = value;
     this.important = important;
     this.disabled = disabled;
     this.parsedOk = parsedOk;
     this.implicit = implicit;  // A longhand, implicitly set by missing values of shorthand.
     this.text = text;
-    this.range = range ? WebInspector.TextRange.fromObject(range) : null;
+    this.range = range ? Common.TextRange.fromObject(range) : null;
     this._active = true;
     this._nameRange = null;
     this._valueRange = null;
   }
 
   /**
-   * @param {!WebInspector.CSSStyleDeclaration} ownerStyle
+   * @param {!SDK.CSSStyleDeclaration} ownerStyle
    * @param {number} index
    * @param {!Protocol.CSS.CSSProperty} payload
-   * @return {!WebInspector.CSSProperty}
+   * @return {!SDK.CSSProperty}
    */
   static parsePayload(ownerStyle, index, payload) {
     // The following default field values are used in the payload:
     // important: false
     // parsedOk: true
     // implicit: false
     // disabled: false
-    var result = new WebInspector.CSSProperty(
+    var result = new SDK.CSSProperty(
         ownerStyle, index, payload.name, payload.value, payload.important || false, payload.disabled || false,
         ('parsedOk' in payload) ? !!payload.parsedOk : true, !!payload.implicit, payload.text, payload.range);
     return result;
   }
 
   _ensureRanges() {
     if (this._nameRange && this._valueRange)
       return;
     var range = this.range;
-    var text = this.text ? new WebInspector.Text(this.text) : null;
+    var text = this.text ? new Common.Text(this.text) : null;
     if (!range || !text)
       return;
 
     var nameIndex = text.value().indexOf(this.name);
     var valueIndex = text.value().lastIndexOf(this.value);
     if (nameIndex === -1 || valueIndex === -1 || nameIndex > valueIndex)
       return;
 
-    var nameSourceRange = new WebInspector.SourceRange(nameIndex, this.name.length);
-    var valueSourceRange = new WebInspector.SourceRange(valueIndex, this.value.length);
+    var nameSourceRange = new Common.SourceRange(nameIndex, this.name.length);
+    var valueSourceRange = new Common.SourceRange(valueIndex, this.value.length);
 
     this._nameRange = rebase(text.toTextRange(nameSourceRange), range.startLine, range.startColumn);
     this._valueRange = rebase(text.toTextRange(valueSourceRange), range.startLine, range.startColumn);
 
     /**
-     * @param {!WebInspector.TextRange} oneLineRange
+     * @param {!Common.TextRange} oneLineRange
      * @param {number} lineOffset
      * @param {number} columnOffset
-     * @return {!WebInspector.TextRange}
+     * @return {!Common.TextRange}
      */
     function rebase(oneLineRange, lineOffset, columnOffset) {
       if (oneLineRange.startLine === 0) {
         oneLineRange.startColumn += columnOffset;
         oneLineRange.endColumn += columnOffset;
       }
       oneLineRange.startLine += lineOffset;
       oneLineRange.endLine += lineOffset;
       return oneLineRange;
     }
   }
 
   /**
-   * @return {?WebInspector.TextRange}
+   * @return {?Common.TextRange}
    */
   nameRange() {
     this._ensureRanges();
     return this._nameRange;
   }
 
   /**
-   * @return {?WebInspector.TextRange}
+   * @return {?Common.TextRange}
    */
   valueRange() {
     this._ensureRanges();
     return this._valueRange;
   }
 
   /**
-   * @param {!WebInspector.CSSModel.Edit} edit
+   * @param {!SDK.CSSModel.Edit} edit
    */
   rebase(edit) {
     if (this.ownerStyle.styleSheetId !== edit.styleSheetId)
       return;
     if (this.range)
       this.range = this.range.rebaseAfterTextEdit(edit.oldRange, edit.newRange);
   }
 
   /**
    * @param {boolean} active
@@ skipping 28 matching lines @@
     if (!this.ownerStyle)
       return Promise.reject(new Error('No ownerStyle for property'));
 
     if (!this.ownerStyle.styleSheetId)
       return Promise.reject(new Error('No owner style id'));
 
     if (!this.range || !this.ownerStyle.range)
       return Promise.reject(new Error('Style not editable'));
 
     if (majorChange)
-      WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.StyleRuleEdited);
+      Host.userMetrics.actionTaken(Host.UserMetrics.Action.StyleRuleEdited);
 
     if (overwrite && propertyText === this.propertyText) {
       if (majorChange)
         this.ownerStyle.cssModel().domModel().markUndoableState();
       return Promise.resolve(true);
     }
 
     var range = this.range.relativeTo(this.ownerStyle.range.startLine, this.ownerStyle.range.startColumn);
     var indentation = this.ownerStyle.cssText ? this._detectIndentation(this.ownerStyle.cssText) :
-                                                WebInspector.moduleSetting('textEditorIndent').get();
+                                                Common.moduleSetting('textEditorIndent').get();
     var endIndentation = this.ownerStyle.cssText ? indentation.substring(0, this.ownerStyle.range.endColumn) : '';
-    var text = new WebInspector.Text(this.ownerStyle.cssText || '');
+    var text = new Common.Text(this.ownerStyle.cssText || '');
     var newStyleText = text.replaceRange(range, String.sprintf(';%s;', propertyText));
 
-    return self.runtime.extension(WebInspector.TokenizerFactory)
+    return self.runtime.extension(Common.TokenizerFactory)
         .instance()
         .then(this._formatStyle.bind(this, newStyleText, indentation, endIndentation))
         .then(setStyleText.bind(this));
 
     /**
      * @param {string} styleText
-     * @this {WebInspector.CSSProperty}
+     * @this {SDK.CSSProperty}
      * @return {!Promise.<boolean>}
      */
     function setStyleText(styleText) {
       return this.ownerStyle.setText(styleText, majorChange);
     }
   }
 
   /**
    * @param {string} styleText
    * @param {string} indentation
    * @param {string} endIndentation
-   * @param {!WebInspector.TokenizerFactory} tokenizerFactory
+   * @param {!Common.TokenizerFactory} tokenizerFactory
    * @return {string}
    */
   _formatStyle(styleText, indentation, endIndentation, tokenizerFactory) {
     if (indentation)
       indentation = '\n' + indentation;
     var result = '';
     var propertyText;
     var insideProperty = false;
     var tokenize = tokenizerFactory.createTokenizer('text/css');
 
@@ skipping 37 matching lines @@
 
     /**
      * @param {string} text
      * @return {boolean}
      */
     function isDisabledProperty(text) {
       var colon = text.indexOf(':');
       if (colon === -1)
         return false;
       var propertyName = text.substring(2, colon).trim();
-      return WebInspector.cssMetadata().isCSSPropertyName(propertyName);
+      return SDK.cssMetadata().isCSSPropertyName(propertyName);
     }
   }
 
   /**
    * @param {string} text
    * @return {string}
    */
   _detectIndentation(text) {
     var lines = text.split('\n');
     if (lines.length < 2)
       return '';
-    return WebInspector.TextUtils.lineIndent(lines[1]);
+    return Common.TextUtils.lineIndent(lines[1]);
   }
 
   /**
    * @param {string} newValue
    * @param {boolean} majorChange
    * @param {boolean} overwrite
    * @param {function(boolean)=} userCallback
    */
   setValue(newValue, majorChange, overwrite, userCallback) {
     var text = this.name + ': ' + newValue + (this.important ? ' !important' : '') + ';';
     this.setText(text, majorChange, overwrite).then(userCallback);
   }
 
   /**
    * @param {boolean} disabled
    * @return {!Promise.<boolean>}
    */
   setDisabled(disabled) {
     if (!this.ownerStyle)
       return Promise.resolve(false);
     if (disabled === this.disabled)
       return Promise.resolve(true);
     var propertyText = this.text.trim();
     var text = disabled ? '/* ' + propertyText + ' */' : this.text.substring(2, propertyText.length - 2).trim();
     return this.setText(text, true, true);
   }
 };