DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/components/ObjectPropertiesSection.js

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. 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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.ObjectPropertiesSection = class extends TreeOutlineInShadow {
+Components.ObjectPropertiesSection = class extends TreeOutlineInShadow {
   /**
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @param {?string|!Element=} title
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!Components.Linkifier=} linkifier
    * @param {?string=} emptyPlaceholder
    * @param {boolean=} ignoreHasOwnProperty
-   * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
+   * @param {!Array.<!SDK.RemoteObjectProperty>=} extraProperties
    */
   constructor(object, title, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties) {
     super();
     this._object = object;
     this._editable = true;
     this.hideOverflow();
     this.setFocusable(false);
-    this._objectTreeElement = new WebInspector.ObjectPropertiesSection.RootElement(
+    this._objectTreeElement = new Components.ObjectPropertiesSection.RootElement(
         object, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties);
     this.appendChild(this._objectTreeElement);
     if (typeof title === 'string' || !title) {
       this.titleElement = this.element.createChild('span');
       this.titleElement.textContent = title || '';
     } else {
       this.titleElement = title;
       this.element.appendChild(title);
     }
 
-    if (object.description && WebInspector.ObjectPropertiesSection._needsAlternateTitle(object)) {
+    if (object.description && Components.ObjectPropertiesSection._needsAlternateTitle(object)) {
       this.expandedTitleElement = createElement('span');
       this.expandedTitleElement.createTextChild(object.description);
 
       var note = this.expandedTitleElement.createChild('span', 'object-state-note');
       note.classList.add('info-note');
-      note.title = WebInspector.UIString('Value below was evaluated just now.');
+      note.title = Common.UIString('Value below was evaluated just now.');
     }
 
     this.element._section = this;
     this.registerRequiredCSS('components/objectValue.css');
     this.registerRequiredCSS('components/objectPropertiesSection.css');
     this.rootElement().childrenListElement.classList.add('source-code', 'object-properties-section');
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} object
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!SDK.RemoteObject} object
+   * @param {!Components.Linkifier=} linkifier
    * @param {boolean=} skipProto
    * @return {!Element}
    */
   static defaultObjectPresentation(object, linkifier, skipProto) {
     var componentRoot = createElementWithClass('span', 'source-code');
-    var shadowRoot = WebInspector.createShadowRootWithCoreStyles(componentRoot, 'components/objectValue.css');
-    shadowRoot.appendChild(WebInspector.ObjectPropertiesSection.createValueElement(object, false));
+    var shadowRoot = UI.createShadowRootWithCoreStyles(componentRoot, 'components/objectValue.css');
+    shadowRoot.appendChild(Components.ObjectPropertiesSection.createValueElement(object, false));
     if (!object.hasChildren)
       return componentRoot;
 
-    var objectPropertiesSection = new WebInspector.ObjectPropertiesSection(object, componentRoot, linkifier);
+    var objectPropertiesSection = new Components.ObjectPropertiesSection(object, componentRoot, linkifier);
     objectPropertiesSection.editable = false;
     if (skipProto)
       objectPropertiesSection.skipProto();
 
     return objectPropertiesSection.element;
   }
 
   /**
-   * @param {!WebInspector.RemoteObjectProperty} propertyA
-   * @param {!WebInspector.RemoteObjectProperty} propertyB
+   * @param {!SDK.RemoteObjectProperty} propertyA
+   * @param {!SDK.RemoteObjectProperty} propertyB
    * @return {number}
    */
   static CompareProperties(propertyA, propertyB) {
     var a = propertyA.name;
     var b = propertyB.name;
     if (a === '__proto__')
       return 1;
     if (b === '__proto__')
       return -1;
     if (propertyA.symbol && !propertyB.symbol)
@@ skipping 16 matching lines @@
     return nameElement;
   }
 
   /**
    * @param {?string=} description
    * @return {string} valueText
    */
   static valueTextForFunctionDescription(description) {
     var text = description.replace(/^function [gs]et /, 'function ');
     var functionPrefixWithArguments =
-        new RegExp(WebInspector.ObjectPropertiesSection._functionPrefixSource.source + '([^)]*)');
+        new RegExp(Components.ObjectPropertiesSection._functionPrefixSource.source + '([^)]*)');
     var matches = functionPrefixWithArguments.exec(text);
     if (!matches) {
       // process shorthand methods
       matches = /[^(]*(\([^)]*)/.exec(text);
     }
     var match = matches ? matches[1] : null;
     return match ? match.replace(/\n/g, ' ') + ')' : (text || '');
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} value
+   * @param {!SDK.RemoteObject} value
    * @param {boolean} wasThrown
    * @param {!Element=} parentElement
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!Components.Linkifier=} linkifier
    * @return {!Element}
    */
   static createValueElementWithCustomSupport(value, wasThrown, parentElement, linkifier) {
     if (value.customPreview()) {
-      var result = (new WebInspector.CustomPreviewComponent(value)).element;
+      var result = (new Components.CustomPreviewComponent(value)).element;
       result.classList.add('object-properties-section-custom-section');
       return result;
     }
-    return WebInspector.ObjectPropertiesSection.createValueElement(value, wasThrown, parentElement, linkifier);
+    return Components.ObjectPropertiesSection.createValueElement(value, wasThrown, parentElement, linkifier);
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} value
+   * @param {!SDK.RemoteObject} value
    * @param {boolean} wasThrown
    * @param {!Element=} parentElement
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!Components.Linkifier=} linkifier
    * @return {!Element}
    */
   static createValueElement(value, wasThrown, parentElement, linkifier) {
     var valueElement = createElementWithClass('span', 'value');
     var type = value.type;
     var subtype = value.subtype;
     var description = value.description;
     var prefix;
     var valueText;
     var suffix;
     if (wasThrown) {
       prefix = '[Exception: ';
       valueText = description;
       suffix = ']';
     } else if (type === 'string' && typeof description === 'string') {
       // Render \n as a nice unicode cr symbol.
       prefix = '"';
       valueText = description.replace(/\n/g, '\u21B5');
       suffix = '"';
     } else if (type === 'function') {
-      valueText = WebInspector.ObjectPropertiesSection.valueTextForFunctionDescription(description);
+      valueText = Components.ObjectPropertiesSection.valueTextForFunctionDescription(description);
     } else if (type !== 'object' || subtype !== 'node') {
       valueText = description;
     }
     if (type !== 'number' || valueText.indexOf('e') === -1) {
       valueElement.setTextContentTruncatedIfNeeded(valueText || '');
       if (prefix)
         valueElement.insertBefore(createTextNode(prefix), valueElement.firstChild);
       if (suffix)
         valueElement.createTextChild(suffix);
     } else {
       var numberParts = valueText.split('e');
       var mantissa = valueElement.createChild('span', 'object-value-scientific-notation-mantissa');
       mantissa.textContent = numberParts[0];
       var exponent = valueElement.createChild('span', 'object-value-scientific-notation-exponent');
       exponent.textContent = 'e' + numberParts[1];
       valueElement.classList.add('object-value-scientific-notation-number');
       if (parentElement)  // FIXME: do it in the caller.
         parentElement.classList.add('hbox');
     }
 
     if (wasThrown)
       valueElement.classList.add('error');
     if (subtype || type)
       valueElement.classList.add('object-value-' + (subtype || type));
 
     if (type === 'object' && subtype === 'node' && description) {
-      WebInspector.DOMPresentationUtils.createSpansForNodeTitle(valueElement, description);
+      Components.DOMPresentationUtils.createSpansForNodeTitle(valueElement, description);
       valueElement.addEventListener('click', mouseClick, false);
       valueElement.addEventListener('mousemove', mouseMove, false);
       valueElement.addEventListener('mouseleave', mouseLeave, false);
     } else {
       valueElement.title = description || '';
     }
 
     if (type === 'object' && subtype === 'internal#location') {
       var rawLocation = value.debuggerModel().createRawLocationByScriptId(
           value.value.scriptId, value.value.lineNumber, value.value.columnNumber);
       if (rawLocation && linkifier)
         return linkifier.linkifyRawLocation(rawLocation, '');
       valueElement.textContent = '<unknown>';
     }
 
     function mouseMove() {
-      WebInspector.DOMModel.highlightObjectAsDOMNode(value);
+      SDK.DOMModel.highlightObjectAsDOMNode(value);
     }
 
     function mouseLeave() {
-      WebInspector.DOMModel.hideDOMNodeHighlight();
+      SDK.DOMModel.hideDOMNodeHighlight();
     }
 
     /**
      * @param {!Event} event
      */
     function mouseClick(event) {
-      WebInspector.Revealer.reveal(value);
+      Common.Revealer.reveal(value);
       event.consume(true);
     }
 
     return valueElement;
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @return {boolean}
    */
   static _needsAlternateTitle(object) {
     return object && object.hasChildren && !object.customPreview() && object.subtype !== 'node' &&
         object.type !== 'function' && (object.type !== 'object' || object.preview);
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} func
+   * @param {!SDK.RemoteObject} func
    * @param {!Element} element
    * @param {boolean} linkify
    * @param {boolean=} includePreview
    */
   static formatObjectAsFunction(func, element, linkify, includePreview) {
     func.debuggerModel().functionDetailsPromise(func).then(didGetDetails);
 
     /**
-     * @param {?WebInspector.DebuggerModel.FunctionDetails} response
+     * @param {?SDK.DebuggerModel.FunctionDetails} response
      */
     function didGetDetails(response) {
       if (!response) {
-        var valueText = WebInspector.ObjectPropertiesSection.valueTextForFunctionDescription(func.description);
+        var valueText = Components.ObjectPropertiesSection.valueTextForFunctionDescription(func.description);
         element.createTextChild(valueText);
         return;
       }
 
-      var matched = func.description.match(WebInspector.ObjectPropertiesSection._functionPrefixSource);
+      var matched = func.description.match(Components.ObjectPropertiesSection._functionPrefixSource);
       if (matched) {
         var prefix = createElementWithClass('span', 'object-value-function-prefix');
         prefix.textContent = matched[0];
         element.appendChild(prefix);
       }
 
       if (linkify && response && response.location) {
         var anchor = createElement('span');
         element.classList.add('linkified');
         element.appendChild(anchor);
         element.addEventListener(
-            'click', WebInspector.Revealer.reveal.bind(WebInspector.Revealer, response.location, undefined));
+            'click', Common.Revealer.reveal.bind(Common.Revealer, response.location, undefined));
         element = anchor;
       }
 
       var text = func.description.substring(0, 200);
       if (includePreview) {
         element.createTextChild(
-            text.replace(WebInspector.ObjectPropertiesSection._functionPrefixSource, '') +
+            text.replace(Components.ObjectPropertiesSection._functionPrefixSource, '') +
             (func.description.length > 200 ? '\u2026' : ''));
         return;
       }
 
       // Now parse description and get the real params and title.
-      self.runtime.extension(WebInspector.TokenizerFactory).instance().then(processTokens);
+      self.runtime.extension(Common.TokenizerFactory).instance().then(processTokens);
 
       var params = null;
       var functionName = response ? response.functionName : '';
 
       /**
-       * @param {!WebInspector.TokenizerFactory} tokenizerFactory
+       * @param {!Common.TokenizerFactory} tokenizerFactory
        */
       function processTokens(tokenizerFactory) {
         var tokenize = tokenizerFactory.createTokenizer('text/javascript');
         tokenize(text, processToken);
         element.createTextChild((functionName || 'anonymous') + '(' + (params || []).join(', ') + ')');
       }
 
       var doneProcessing = false;
 
       /**
@@ skipping 38 matching lines @@
    */
   objectTreeElement() {
     return this._objectTreeElement;
   }
 
   enableContextMenu() {
     this.element.addEventListener('contextmenu', this._contextMenuEventFired.bind(this), false);
   }
 
   _contextMenuEventFired(event) {
-    var contextMenu = new WebInspector.ContextMenu(event);
+    var contextMenu = new UI.ContextMenu(event);
     contextMenu.appendApplicableItems(this._object);
     contextMenu.show();
   }
 
   titleLessMode() {
     this._objectTreeElement.listItemElement.classList.add('hidden');
     this._objectTreeElement.childrenListElement.classList.add('title-less-mode');
     this._objectTreeElement.expand();
   }
 };
 
 /** @const */
-WebInspector.ObjectPropertiesSection._arrayLoadThreshold = 100;
+Components.ObjectPropertiesSection._arrayLoadThreshold = 100;
 
 
 /**
  * @unrestricted
  */
-WebInspector.ObjectPropertiesSection.RootElement = class extends TreeElement {
+Components.ObjectPropertiesSection.RootElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.RemoteObject} object
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!SDK.RemoteObject} object
+   * @param {!Components.Linkifier=} linkifier
    * @param {?string=} emptyPlaceholder
    * @param {boolean=} ignoreHasOwnProperty
-   * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
+   * @param {!Array.<!SDK.RemoteObjectProperty>=} extraProperties
    */
   constructor(object, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties) {
     var contentElement = createElement('content');
     super(contentElement);
 
     this._object = object;
     this._extraProperties = extraProperties || [];
     this._ignoreHasOwnProperty = !!ignoreHasOwnProperty;
     this._emptyPlaceholder = emptyPlaceholder;
 
@@ skipping 42 matching lines @@
    * @return {boolean}
    */
   ondblclick(e) {
     return true;
   }
 
   /**
    * @override
    */
   onpopulate() {
-    WebInspector.ObjectPropertyTreeElement._populate(
+    Components.ObjectPropertyTreeElement._populate(
         this, this._object, !!this.treeOutline._skipProto, this._linkifier, this._emptyPlaceholder,
         this._ignoreHasOwnProperty, this._extraProperties);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ObjectPropertyTreeElement = class extends TreeElement {
+Components.ObjectPropertyTreeElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.RemoteObjectProperty} property
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!SDK.RemoteObjectProperty} property
+   * @param {!Components.Linkifier=} linkifier
    */
   constructor(property, linkifier) {
     // Pass an empty title, the title gets made later in onattach.
     super();
 
     this.property = property;
     this.toggleOnClick = true;
     this.selectable = false;
     /** @type {!Array.<!Object>} */
     this._highlightChanges = [];
     this._linkifier = linkifier;
   }
 
   /**
    * @param {!TreeElement} treeElement
-   * @param {!WebInspector.RemoteObject} value
+   * @param {!SDK.RemoteObject} value
    * @param {boolean} skipProto
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!Components.Linkifier=} linkifier
    * @param {?string=} emptyPlaceholder
    * @param {boolean=} flattenProtoChain
-   * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
-   * @param {!WebInspector.RemoteObject=} targetValue
+   * @param {!Array.<!SDK.RemoteObjectProperty>=} extraProperties
+   * @param {!SDK.RemoteObject=} targetValue
    */
   static _populate(
       treeElement,
       value,
       skipProto,
       linkifier,
       emptyPlaceholder,
       flattenProtoChain,
       extraProperties,
       targetValue) {
-    if (value.arrayLength() > WebInspector.ObjectPropertiesSection._arrayLoadThreshold) {
+    if (value.arrayLength() > Components.ObjectPropertiesSection._arrayLoadThreshold) {
       treeElement.removeChildren();
-      WebInspector.ArrayGroupingTreeElement._populateArray(treeElement, value, 0, value.arrayLength() - 1, linkifier);
+      Components.ArrayGroupingTreeElement._populateArray(treeElement, value, 0, value.arrayLength() - 1, linkifier);
       return;
     }
 
     /**
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} internalProperties
      */
     function callback(properties, internalProperties) {
       treeElement.removeChildren();
       if (!properties)
         return;
 
       extraProperties = extraProperties || [];
       for (var i = 0; i < extraProperties.length; ++i)
         properties.push(extraProperties[i]);
 
-      WebInspector.ObjectPropertyTreeElement.populateWithProperties(
+      Components.ObjectPropertyTreeElement.populateWithProperties(
           treeElement, properties, internalProperties, skipProto, targetValue || value, linkifier, emptyPlaceholder);
     }
 
     if (flattenProtoChain)
       value.getAllProperties(false, callback);
     else
-      WebInspector.RemoteObject.loadFromObjectPerProto(value, callback);
+      SDK.RemoteObject.loadFromObjectPerProto(value, callback);
   }
 
   /**
    * @param {!TreeElement} treeNode
-   * @param {!Array.<!WebInspector.RemoteObjectProperty>} properties
-   * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
+   * @param {!Array.<!SDK.RemoteObjectProperty>} properties
+   * @param {?Array.<!SDK.RemoteObjectProperty>} internalProperties
    * @param {boolean} skipProto
-   * @param {?WebInspector.RemoteObject} value
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {?SDK.RemoteObject} value
+   * @param {!Components.Linkifier=} linkifier
    * @param {?string=} emptyPlaceholder
    */
   static populateWithProperties(
       treeNode,
       properties,
       internalProperties,
       skipProto,
       value,
       linkifier,
       emptyPlaceholder) {
-    properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
+    properties.sort(Components.ObjectPropertiesSection.CompareProperties);
 
     var tailProperties = [];
     var protoProperty = null;
     for (var i = 0; i < properties.length; ++i) {
       var property = properties[i];
       property.parentObject = value;
       if (property.name === '__proto__' && !property.isAccessorProperty()) {
         protoProperty = property;
         continue;
       }
 
       if (property.isOwn && property.getter) {
-        var getterProperty = new WebInspector.RemoteObjectProperty('get ' + property.name, property.getter, false);
+        var getterProperty = new SDK.RemoteObjectProperty('get ' + property.name, property.getter, false);
         getterProperty.parentObject = value;
         tailProperties.push(getterProperty);
       }
       if (property.isOwn && property.setter) {
-        var setterProperty = new WebInspector.RemoteObjectProperty('set ' + property.name, property.setter, false);
+        var setterProperty = new SDK.RemoteObjectProperty('set ' + property.name, property.setter, false);
         setterProperty.parentObject = value;
         tailProperties.push(setterProperty);
       }
       var canShowProperty = property.getter || !property.isAccessorProperty();
       if (canShowProperty && property.name !== '__proto__')
-        treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(property, linkifier));
+        treeNode.appendChild(new Components.ObjectPropertyTreeElement(property, linkifier));
     }
     for (var i = 0; i < tailProperties.length; ++i)
-      treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(tailProperties[i], linkifier));
+      treeNode.appendChild(new Components.ObjectPropertyTreeElement(tailProperties[i], linkifier));
     if (!skipProto && protoProperty)
-      treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(protoProperty, linkifier));
+      treeNode.appendChild(new Components.ObjectPropertyTreeElement(protoProperty, linkifier));
 
     if (internalProperties) {
       for (var i = 0; i < internalProperties.length; i++) {
         internalProperties[i].parentObject = value;
-        var treeElement = new WebInspector.ObjectPropertyTreeElement(internalProperties[i], linkifier);
+        var treeElement = new Components.ObjectPropertyTreeElement(internalProperties[i], linkifier);
         if (internalProperties[i].name === '[[Entries]]') {
           treeElement.setExpandable(true);
           treeElement.expand();
         }
         treeNode.appendChild(treeElement);
       }
     }
 
-    WebInspector.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded(treeNode, emptyPlaceholder);
+    Components.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded(treeNode, emptyPlaceholder);
   }
 
   /**
    * @param {!TreeElement} treeNode
    * @param {?string=} emptyPlaceholder
    */
   static _appendEmptyPlaceholderIfNeeded(treeNode, emptyPlaceholder) {
     if (treeNode.childCount())
       return;
     var title = createElementWithClass('div', 'gray-info-message');
-    title.textContent = emptyPlaceholder || WebInspector.UIString('No Properties');
+    title.textContent = emptyPlaceholder || Common.UIString('No Properties');
     var infoElement = new TreeElement(title);
     treeNode.appendChild(infoElement);
   }
 
   /**
-   * @param {?WebInspector.RemoteObject} object
+   * @param {?SDK.RemoteObject} object
    * @param {!Array.<string>} propertyPath
-   * @param {function(?WebInspector.RemoteObject, boolean=)} callback
+   * @param {function(?SDK.RemoteObject, boolean=)} callback
    * @return {!Element}
    */
   static createRemoteObjectAccessorPropertySpan(object, propertyPath, callback) {
     var rootElement = createElement('span');
     var element = rootElement.createChild('span');
-    element.textContent = WebInspector.UIString('(...)');
+    element.textContent = Common.UIString('(...)');
     if (!object)
       return rootElement;
     element.classList.add('object-value-calculate-value-button');
-    element.title = WebInspector.UIString('Invoke property getter');
+    element.title = Common.UIString('Invoke property getter');
     element.addEventListener('click', onInvokeGetterClick, false);
 
     function onInvokeGetterClick(event) {
       event.consume();
       object.getProperty(propertyPath, callback);
     }
 
     return rootElement;
   }
 
   /**
    * @param {!RegExp} regex
    * @param {string=} additionalCssClassName
    * @return {boolean}
    */
   setSearchRegex(regex, additionalCssClassName) {
-    var cssClasses = WebInspector.highlightedSearchResultClassName;
+    var cssClasses = UI.highlightedSearchResultClassName;
     if (additionalCssClassName)
       cssClasses += ' ' + additionalCssClassName;
     this.revertHighlightChanges();
 
     this._applySearch(regex, this.nameElement, cssClasses);
     var valueType = this.property.value.type;
     if (valueType !== 'object')
       this._applySearch(regex, this.valueElement, cssClasses);
 
     return !!this._highlightChanges.length;
   }
 
   /**
    * @param {!RegExp} regex
    * @param {!Element} element
    * @param {string} cssClassName
    */
   _applySearch(regex, element, cssClassName) {
     var ranges = [];
     var content = element.textContent;
     regex.lastIndex = 0;
     var match = regex.exec(content);
     while (match) {
-      ranges.push(new WebInspector.SourceRange(match.index, match[0].length));
+      ranges.push(new Common.SourceRange(match.index, match[0].length));
       match = regex.exec(content);
     }
     if (ranges.length)
-      WebInspector.highlightRangesWithStyleClass(element, ranges, cssClassName, this._highlightChanges);
+      UI.highlightRangesWithStyleClass(element, ranges, cssClassName, this._highlightChanges);
   }
 
   revertHighlightChanges() {
-    WebInspector.revertDomChanges(this._highlightChanges);
+    UI.revertDomChanges(this._highlightChanges);
     this._highlightChanges = [];
   }
 
   /**
    * @override
    */
   onpopulate() {
-    var propertyValue = /** @type {!WebInspector.RemoteObject} */ (this.property.value);
+    var propertyValue = /** @type {!SDK.RemoteObject} */ (this.property.value);
     console.assert(propertyValue);
     var skipProto = this.treeOutline ? this.treeOutline._skipProto : true;
     var targetValue = this.property.name !== '__proto__' ? propertyValue : this.property.parentObject;
-    WebInspector.ObjectPropertyTreeElement._populate(
+    Components.ObjectPropertyTreeElement._populate(
         this, propertyValue, skipProto, this._linkifier, undefined, undefined, undefined, targetValue);
   }
 
   /**
    * @override
    * @return {boolean}
    */
   ondblclick(event) {
     var inEditableElement = event.target.isSelfOrDescendant(this.valueElement) ||
         (this.expandedValueElement && event.target.isSelfOrDescendant(this.expandedValueElement));
@@ skipping 30 matching lines @@
   _showExpandedValueElement(value) {
     if (!this.expandedValueElement)
       return;
     if (value)
       this.listItemElement.replaceChild(this.expandedValueElement, this.valueElement);
     else
       this.listItemElement.replaceChild(this.valueElement, this.expandedValueElement);
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} value
+   * @param {!SDK.RemoteObject} value
    * @return {?Element}
    */
   _createExpandedValueElement(value) {
-    if (!WebInspector.ObjectPropertiesSection._needsAlternateTitle(value))
+    if (!Components.ObjectPropertiesSection._needsAlternateTitle(value))
       return null;
 
     var valueElement = createElementWithClass('span', 'value');
     valueElement.setTextContentTruncatedIfNeeded(value.description || '');
     valueElement.classList.add('object-value-' + (value.subtype || value.type));
     valueElement.title = value.description || '';
     return valueElement;
   }
 
   update() {
-    this.nameElement = WebInspector.ObjectPropertiesSection.createNameElement(this.property.name);
+    this.nameElement = Components.ObjectPropertiesSection.createNameElement(this.property.name);
     if (!this.property.enumerable)
       this.nameElement.classList.add('object-properties-section-dimmed');
     if (this.property.synthetic)
       this.nameElement.classList.add('synthetic-property');
 
     this._updatePropertyPath();
     this.nameElement.addEventListener('contextmenu', this._contextMenuFired.bind(this, this.property), false);
 
     var separatorElement = createElementWithClass('span', 'object-properties-section-separator');
     separatorElement.textContent = ': ';
 
     if (this.property.value) {
-      this.valueElement = WebInspector.ObjectPropertiesSection.createValueElementWithCustomSupport(
+      this.valueElement = Components.ObjectPropertiesSection.createValueElementWithCustomSupport(
           this.property.value, this.property.wasThrown, this.listItemElement, this._linkifier);
       this.valueElement.addEventListener('contextmenu', this._contextMenuFired.bind(this, this.property), false);
     } else if (this.property.getter) {
-      this.valueElement = WebInspector.ObjectPropertyTreeElement.createRemoteObjectAccessorPropertySpan(
+      this.valueElement = Components.ObjectPropertyTreeElement.createRemoteObjectAccessorPropertySpan(
           this.property.parentObject, [this.property.name], this._onInvokeGetterClick.bind(this));
     } else {
       this.valueElement = createElementWithClass('span', 'object-value-undefined');
-      this.valueElement.textContent = WebInspector.UIString('<unreadable>');
-      this.valueElement.title = WebInspector.UIString('No property getter');
+      this.valueElement.textContent = Common.UIString('<unreadable>');
+      this.valueElement.title = Common.UIString('No property getter');
     }
 
     var valueText = this.valueElement.textContent;
     if (this.property.value && valueText && !this.property.wasThrown)
       this.expandedValueElement = this._createExpandedValueElement(this.property.value);
 
     this.listItemElement.removeChildren();
     this.listItemElement.appendChildren(this.nameElement, separatorElement, this.valueElement);
   }
 
   _updatePropertyPath() {
     if (this.nameElement.title)
       return;
 
     var useDotNotation = /^(_|\$|[A-Z])(_|\$|[A-Z]|\d)*$/i;
     var isInteger = /^[1-9]\d*$/;
     var name = this.property.name;
     var parentPath = this.parent.nameElement ? this.parent.nameElement.title : '';
     if (useDotNotation.test(name))
       this.nameElement.title = parentPath + '.' + name;
     else if (isInteger.test(name))
       this.nameElement.title = parentPath + '[' + name + ']';
     else
       this.nameElement.title = parentPath + '["' + name + '"]';
   }
 
   /**
-   * @param {!WebInspector.RemoteObjectProperty} property
+   * @param {!SDK.RemoteObjectProperty} property
    * @param {!Event} event
    */
   _contextMenuFired(property, event) {
-    var contextMenu = new WebInspector.ContextMenu(event);
+    var contextMenu = new UI.ContextMenu(event);
     if (property.symbol)
       contextMenu.appendApplicableItems(property.symbol);
     if (property.value)
       contextMenu.appendApplicableItems(property.value);
     var copyPathHandler = InspectorFrontendHost.copyText.bind(InspectorFrontendHost, this.nameElement.title);
     contextMenu.beforeShow(() => {
-      contextMenu.appendItem(WebInspector.UIString.capitalize('Copy ^property ^path'), copyPathHandler);
+      contextMenu.appendItem(Common.UIString.capitalize('Copy ^property ^path'), copyPathHandler);
     });
     contextMenu.show();
   }
 
   _startEditing() {
     if (this._prompt || !this.treeOutline._editable || this._readOnly)
       return;
 
     this._editableDiv = this.listItemElement.createChild('span');
 
     var text = this.property.value.description;
     if (this.property.value.type === 'string' && typeof text === 'string')
       text = '"' + text + '"';
 
-    this._editableDiv.setTextContentTruncatedIfNeeded(text, WebInspector.UIString('<string is too large to edit>'));
+    this._editableDiv.setTextContentTruncatedIfNeeded(text, Common.UIString('<string is too large to edit>'));
     var originalContent = this._editableDiv.textContent;
 
     // Lie about our children to prevent expanding on double click and to collapse subproperties.
     this.setExpandable(false);
     this.listItemElement.classList.add('editing-sub-part');
     this.valueElement.classList.add('hidden');
 
-    this._prompt = new WebInspector.ObjectPropertyPrompt();
+    this._prompt = new Components.ObjectPropertyPrompt();
 
     var proxyElement =
         this._prompt.attachAndStartEditing(this._editableDiv, this._editingCommitted.bind(this, originalContent));
     this.listItemElement.getComponentSelection().setBaseAndExtent(this._editableDiv, 0, this._editableDiv, 1);
     proxyElement.addEventListener('keydown', this._promptKeyDown.bind(this, originalContent), false);
   }
 
   _editingEnded() {
     this._prompt.detach();
     delete this._prompt;
@@ skipping 36 matching lines @@
       event.consume();
       this._editingCancelled();
       return;
     }
   }
 
   /**
    * @param {string} expression
    */
   _applyExpression(expression) {
-    var property = WebInspector.RemoteObject.toCallArgument(this.property.symbol || this.property.name);
+    var property = SDK.RemoteObject.toCallArgument(this.property.symbol || this.property.name);
     expression = expression.trim();
     if (expression)
       this.property.parentObject.setPropertyValue(property, expression, callback.bind(this));
     else
       this.property.parentObject.deleteProperty(property, callback.bind(this));
 
     /**
      * @param {?Protocol.Error} error
-     * @this {WebInspector.ObjectPropertyTreeElement}
+     * @this {Components.ObjectPropertyTreeElement}
      */
     function callback(error) {
       if (error) {
         this.update();
         return;
       }
 
       if (!expression) {
         // The property was deleted, so remove this tree element.
         this.parent.removeChild(this);
       } else {
         // Call updateSiblings since their value might be based on the value that just changed.
         var parent = this.parent;
         parent.invalidateChildren();
         parent.onpopulate();
       }
     }
   }
 
   /**
-   * @param {?WebInspector.RemoteObject} result
+   * @param {?SDK.RemoteObject} result
    * @param {boolean=} wasThrown
    */
   _onInvokeGetterClick(result, wasThrown) {
     if (!result)
       return;
     this.property.value = result;
     this.property.wasThrown = wasThrown;
 
     this.update();
     this.invalidateChildren();
     this._updateExpandable();
   }
 
   _updateExpandable() {
     if (this.property.value)
       this.setExpandable(
           !this.property.value.customPreview() && this.property.value.hasChildren && !this.property.wasThrown);
     else
       this.setExpandable(false);
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.ArrayGroupingTreeElement = class extends TreeElement {
+Components.ArrayGroupingTreeElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @param {number} fromIndex
    * @param {number} toIndex
    * @param {number} propertyCount
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!Components.Linkifier=} linkifier
    */
   constructor(object, fromIndex, toIndex, propertyCount, linkifier) {
     super(String.sprintf('[%d \u2026 %d]', fromIndex, toIndex), true);
     this.toggleOnClick = true;
     this.selectable = false;
     this._fromIndex = fromIndex;
     this._toIndex = toIndex;
     this._object = object;
     this._readOnly = true;
     this._propertyCount = propertyCount;
     this._linkifier = linkifier;
   }
 
   /**
    * @param {!TreeElement} treeNode
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @param {number} fromIndex
    * @param {number} toIndex
-   * @param {!WebInspector.Linkifier=} linkifier
+   * @param {!Components.Linkifier=} linkifier
    */
   static _populateArray(treeNode, object, fromIndex, toIndex, linkifier) {
-    WebInspector.ArrayGroupingTreeElement._populateRanges(treeNode, object, fromIndex, toIndex, true, linkifier);
+    Components.ArrayGroupingTreeElement._populateRanges(treeNode, object, fromIndex, toIndex, true, linkifier);
   }
 
   /**
    * @param {!TreeElement} treeNode
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @param {number} fromIndex
    * @param {number} toIndex
    * @param {boolean} topLevel
-   * @param {!WebInspector.Linkifier=} linkifier
-   * @this {WebInspector.ArrayGroupingTreeElement}
+   * @param {!Components.Linkifier=} linkifier
+   * @this {Components.ArrayGroupingTreeElement}
    */
   static _populateRanges(treeNode, object, fromIndex, toIndex, topLevel, linkifier) {
     object.callFunctionJSON(
         packRanges,
         [
-          {value: fromIndex}, {value: toIndex}, {value: WebInspector.ArrayGroupingTreeElement._bucketThreshold},
-          {value: WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold},
-          {value: WebInspector.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold}
+          {value: fromIndex}, {value: toIndex}, {value: Components.ArrayGroupingTreeElement._bucketThreshold},
+          {value: Components.ArrayGroupingTreeElement._sparseIterationThreshold},
+          {value: Components.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold}
         ],
         callback);
 
     /**
      * Note: must declare params as optional.
      * @param {number=} fromIndex
      * @param {number=} toIndex
      * @param {number=} bucketThreshold
      * @param {number=} sparseIterationThreshold
      * @param {number=} getOwnPropertyNamesThreshold
@@ skipping 64 matching lines @@
       }
 
       return {ranges: ranges, skipGetOwnPropertyNames: skipGetOwnPropertyNames};
     }
 
     function callback(result) {
       if (!result)
         return;
       var ranges = /** @type {!Array.<!Array.<number>>} */ (result.ranges);
       if (ranges.length === 1) {
-        WebInspector.ArrayGroupingTreeElement._populateAsFragment(
+        Components.ArrayGroupingTreeElement._populateAsFragment(
             treeNode, object, ranges[0][0], ranges[0][1], linkifier);
       } else {
         for (var i = 0; i < ranges.length; ++i) {
           var fromIndex = ranges[i][0];
           var toIndex = ranges[i][1];
           var count = ranges[i][2];
           if (fromIndex === toIndex)
-            WebInspector.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, fromIndex, toIndex, linkifier);
+            Components.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, fromIndex, toIndex, linkifier);
           else
             treeNode.appendChild(
-                new WebInspector.ArrayGroupingTreeElement(object, fromIndex, toIndex, count, linkifier));
+                new Components.ArrayGroupingTreeElement(object, fromIndex, toIndex, count, linkifier));
         }
       }
       if (topLevel)
-        WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties(
+        Components.ArrayGroupingTreeElement._populateNonIndexProperties(
             treeNode, object, result.skipGetOwnPropertyNames, linkifier);
     }
   }
 
   /**
    * @param {!TreeElement} treeNode
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @param {number} fromIndex
    * @param {number} toIndex
-   * @param {!WebInspector.Linkifier=} linkifier
-   * @this {WebInspector.ArrayGroupingTreeElement}
+   * @param {!Components.Linkifier=} linkifier
+   * @this {Components.ArrayGroupingTreeElement}
    */
   static _populateAsFragment(treeNode, object, fromIndex, toIndex, linkifier) {
     object.callFunction(
         buildArrayFragment,
         [
           {value: fromIndex}, {value: toIndex},
-          {value: WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold}
+          {value: Components.ArrayGroupingTreeElement._sparseIterationThreshold}
         ],
         processArrayFragment.bind(this));
 
     /**
      * @suppressReceiverCheck
      * @this {Object}
      * @param {number=} fromIndex // must declare optional
      * @param {number=} toIndex // must declare optional
      * @param {number=} sparseIterationThreshold // must declare optional
      */
@@ skipping 10 matching lines @@
           var name = ownPropertyNames[i];
           var index = name >>> 0;
           if (String(index) === name && fromIndex <= index && index <= toIndex)
             result[index] = this[index];
         }
       }
       return result;
     }
 
     /**
-     * @param {?WebInspector.RemoteObject} arrayFragment
+     * @param {?SDK.RemoteObject} arrayFragment
      * @param {boolean=} wasThrown
-     * @this {WebInspector.ArrayGroupingTreeElement}
+     * @this {Components.ArrayGroupingTreeElement}
      */
     function processArrayFragment(arrayFragment, wasThrown) {
       if (!arrayFragment || wasThrown)
         return;
       arrayFragment.getAllProperties(false, processProperties.bind(this));
     }
 
-    /** @this {WebInspector.ArrayGroupingTreeElement} */
+    /** @this {Components.ArrayGroupingTreeElement} */
     function processProperties(properties, internalProperties) {
       if (!properties)
         return;
 
-      properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
+      properties.sort(Components.ObjectPropertiesSection.CompareProperties);
       for (var i = 0; i < properties.length; ++i) {
         properties[i].parentObject = this._object;
-        var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i], linkifier);
+        var childTreeElement = new Components.ObjectPropertyTreeElement(properties[i], linkifier);
         childTreeElement._readOnly = true;
         treeNode.appendChild(childTreeElement);
       }
     }
   }
 
   /**
    * @param {!TreeElement} treeNode
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    * @param {boolean} skipGetOwnPropertyNames
-   * @param {!WebInspector.Linkifier=} linkifier
-   * @this {WebInspector.ArrayGroupingTreeElement}
+   * @param {!Components.Linkifier=} linkifier
+   * @this {Components.ArrayGroupingTreeElement}
    */
   static _populateNonIndexProperties(treeNode, object, skipGetOwnPropertyNames, linkifier) {
     object.callFunction(buildObjectFragment, [{value: skipGetOwnPropertyNames}], processObjectFragment.bind(this));
 
     /**
      * @param {boolean=} skipGetOwnPropertyNames
      * @suppressReceiverCheck
      * @this {Object}
      */
     function buildObjectFragment(skipGetOwnPropertyNames) {
       var result = {__proto__: this.__proto__};
       if (skipGetOwnPropertyNames)
         return result;
       var names = Object.getOwnPropertyNames(this);
       for (var i = 0; i < names.length; ++i) {
         var name = names[i];
         // Array index check according to the ES5-15.4.
         if (String(name >>> 0) === name && name >>> 0 !== 0xffffffff)
           continue;
         var descriptor = Object.getOwnPropertyDescriptor(this, name);
         if (descriptor)
           Object.defineProperty(result, name, descriptor);
       }
       return result;
     }
 
     /**
-     * @param {?WebInspector.RemoteObject} arrayFragment
+     * @param {?SDK.RemoteObject} arrayFragment
      * @param {boolean=} wasThrown
-     * @this {WebInspector.ArrayGroupingTreeElement}
+     * @this {Components.ArrayGroupingTreeElement}
      */
     function processObjectFragment(arrayFragment, wasThrown) {
       if (!arrayFragment || wasThrown)
         return;
       arrayFragment.getOwnProperties(processProperties.bind(this));
     }
 
     /**
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>=} internalProperties
-     * @this {WebInspector.ArrayGroupingTreeElement}
+     * @param {?Array.<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array.<!SDK.RemoteObjectProperty>=} internalProperties
+     * @this {Components.ArrayGroupingTreeElement}
      */
     function processProperties(properties, internalProperties) {
       if (!properties)
         return;
-      properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
+      properties.sort(Components.ObjectPropertiesSection.CompareProperties);
       for (var i = 0; i < properties.length; ++i) {
         properties[i].parentObject = this._object;
-        var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i], linkifier);
+        var childTreeElement = new Components.ObjectPropertyTreeElement(properties[i], linkifier);
         childTreeElement._readOnly = true;
         treeNode.appendChild(childTreeElement);
       }
     }
   }
 
   /**
    * @override
    */
   onpopulate() {
-    if (this._propertyCount >= WebInspector.ArrayGroupingTreeElement._bucketThreshold) {
-      WebInspector.ArrayGroupingTreeElement._populateRanges(
+    if (this._propertyCount >= Components.ArrayGroupingTreeElement._bucketThreshold) {
+      Components.ArrayGroupingTreeElement._populateRanges(
           this, this._object, this._fromIndex, this._toIndex, false, this._linkifier);
       return;
     }
-    WebInspector.ArrayGroupingTreeElement._populateAsFragment(
+    Components.ArrayGroupingTreeElement._populateAsFragment(
         this, this._object, this._fromIndex, this._toIndex, this._linkifier);
   }
 
   /**
    * @override
    */
   onattach() {
     this.listItemElement.classList.add('object-properties-section-name');
   }
 };
 
-WebInspector.ArrayGroupingTreeElement._bucketThreshold = 100;
-WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold = 250000;
-WebInspector.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold = 500000;
+Components.ArrayGroupingTreeElement._bucketThreshold = 100;
+Components.ArrayGroupingTreeElement._sparseIterationThreshold = 250000;
+Components.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold = 500000;
 
 
 /**
  * @unrestricted
  */
-WebInspector.ObjectPropertyPrompt = class extends WebInspector.TextPrompt {
+Components.ObjectPropertyPrompt = class extends UI.TextPrompt {
   constructor() {
     super();
-    this.initialize(WebInspector.JavaScriptAutocomplete.completionsForTextPromptInCurrentContext);
+    this.initialize(Components.JavaScriptAutocomplete.completionsForTextPromptInCurrentContext);
     this.setSuggestBoxEnabled(true);
   }
 };
 
 
-WebInspector.ObjectPropertiesSection._functionPrefixSource = /^(?:async\s)?function\*?\s/;
+Components.ObjectPropertiesSection._functionPrefixSource = /^(?:async\s)?function\*?\s/;
 
 
 /**
  * @unrestricted
  */
-WebInspector.ObjectPropertiesSectionExpandController = class {
+Components.ObjectPropertiesSectionExpandController = class {
   constructor() {
     /** @type {!Set.<string>} */
     this._expandedProperties = new Set();
   }
 
   /**
    * @param {string} id
-   * @param {!WebInspector.ObjectPropertiesSection} section
+   * @param {!Components.ObjectPropertiesSection} section
    */
   watchSection(id, section) {
     section.addEventListener(TreeOutline.Events.ElementAttached, this._elementAttached, this);
     section.addEventListener(TreeOutline.Events.ElementExpanded, this._elementExpanded, this);
     section.addEventListener(TreeOutline.Events.ElementCollapsed, this._elementCollapsed, this);
-    section[WebInspector.ObjectPropertiesSectionExpandController._treeOutlineId] = id;
+    section[Components.ObjectPropertiesSectionExpandController._treeOutlineId] = id;
 
     if (this._expandedProperties.has(id))
       section.expand();
   }
 
   /**
    * @param {string} id
    */
   stopWatchSectionsWithId(id) {
     for (var property of this._expandedProperties) {
       if (property.startsWith(id + ':'))
         this._expandedProperties.delete(property);
     }
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _elementAttached(event) {
     var element = /** @type {!TreeElement} */ (event.data);
     if (element.isExpandable() && this._expandedProperties.has(this._propertyPath(element)))
       element.expand();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _elementExpanded(event) {
     var element = /** @type {!TreeElement} */ (event.data);
     this._expandedProperties.add(this._propertyPath(element));
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _elementCollapsed(event) {
     var element = /** @type {!TreeElement} */ (event.data);
     this._expandedProperties.delete(this._propertyPath(element));
   }
 
   /**
    * @param {!TreeElement} treeElement
    * @return {string}
    */
   _propertyPath(treeElement) {
-    var cachedPropertyPath = treeElement[WebInspector.ObjectPropertiesSectionExpandController._cachedPathSymbol];
+    var cachedPropertyPath = treeElement[Components.ObjectPropertiesSectionExpandController._cachedPathSymbol];
     if (cachedPropertyPath)
       return cachedPropertyPath;
 
     var current = treeElement;
     var rootElement = treeElement.treeOutline.objectTreeElement();
 
     var result;
 
     while (current !== rootElement) {
       var currentName = '';
       if (current.property)
         currentName = current.property.name;
       else
         currentName = typeof current.title === 'string' ? current.title : current.title.textContent;
 
       result = currentName + (result ? '.' + result : '');
       current = current.parent;
     }
-    var treeOutlineId = treeElement.treeOutline[WebInspector.ObjectPropertiesSectionExpandController._treeOutlineId];
+    var treeOutlineId = treeElement.treeOutline[Components.ObjectPropertiesSectionExpandController._treeOutlineId];
     result = treeOutlineId + (result ? ':' + result : '');
-    treeElement[WebInspector.ObjectPropertiesSectionExpandController._cachedPathSymbol] = result;
+    treeElement[Components.ObjectPropertiesSectionExpandController._cachedPathSymbol] = result;
     return result;
   }
 };
 
-WebInspector.ObjectPropertiesSectionExpandController._cachedPathSymbol = Symbol('cachedPath');
-WebInspector.ObjectPropertiesSectionExpandController._treeOutlineId = Symbol('treeOutlineId');
+Components.ObjectPropertiesSectionExpandController._cachedPathSymbol = Symbol('cachedPath');
+Components.ObjectPropertiesSectionExpandController._treeOutlineId = Symbol('treeOutlineId');