DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/audits/AuditsPanel.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 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.AuditsPanel = class extends WebInspector.PanelWithSidebar {
+Audits.AuditsPanel = class extends UI.PanelWithSidebar {
   constructor() {
     super('audits');
     this.registerRequiredCSS('ui/panelEnablerView.css');
     this.registerRequiredCSS('audits/auditsPanel.css');
 
     this._sidebarTree = new TreeOutlineInShadow();
     this._sidebarTree.registerRequiredCSS('audits/auditsSidebarTree.css');
     this.panelSidebarElement().appendChild(this._sidebarTree.element);
 
-    this._auditsItemTreeElement = new WebInspector.AuditsSidebarTreeElement(this);
+    this._auditsItemTreeElement = new Audits.AuditsSidebarTreeElement(this);
     this._sidebarTree.appendChild(this._auditsItemTreeElement);
 
-    this._auditResultsTreeElement = new TreeElement(WebInspector.UIString('RESULTS'), true);
+    this._auditResultsTreeElement = new TreeElement(Common.UIString('RESULTS'), true);
     this._auditResultsTreeElement.selectable = false;
     this._auditResultsTreeElement.listItemElement.classList.add('audits-sidebar-results');
     this._auditResultsTreeElement.expand();
     this._sidebarTree.appendChild(this._auditResultsTreeElement);
 
     this._constructCategories();
 
-    this._auditController = new WebInspector.AuditController(this);
-    this._launcherView = new WebInspector.AuditLauncherView(this._auditController);
+    this._auditController = new Audits.AuditController(this);
+    this._launcherView = new Audits.AuditLauncherView(this._auditController);
     for (var id in this.categoriesById)
       this._launcherView.addCategory(this.categoriesById[id]);
 
-    var extensionCategories = WebInspector.extensionServer.auditCategories();
+    var extensionCategories = Extensions.extensionServer.auditCategories();
     for (var i = 0; i < extensionCategories.length; ++i) {
       var category = extensionCategories[i];
-      this.addCategory(new WebInspector.AuditExtensionCategory(
+      this.addCategory(new Audits.AuditExtensionCategory(
           category.extensionOrigin, category.id, category.displayName, category.ruleCount));
     }
-    WebInspector.extensionServer.addEventListener(
-        WebInspector.ExtensionServer.Events.AuditCategoryAdded, this._extensionAuditCategoryAdded, this);
+    Extensions.extensionServer.addEventListener(
+        Extensions.ExtensionServer.Events.AuditCategoryAdded, this._extensionAuditCategoryAdded, this);
   }
 
   /**
-   * @return {!WebInspector.AuditsPanel}
+   * @return {!Audits.AuditsPanel}
    */
   static instance() {
-    return /** @type {!WebInspector.AuditsPanel} */ (self.runtime.sharedInstance(WebInspector.AuditsPanel));
+    return /** @type {!Audits.AuditsPanel} */ (self.runtime.sharedInstance(Audits.AuditsPanel));
   }
 
   /**
-   * @return {!Object.<string, !WebInspector.AuditCategory>}
+   * @return {!Object.<string, !Audits.AuditCategory>}
    */
   get categoriesById() {
     return this._auditCategoriesById;
   }
 
   /**
-   * @param {!WebInspector.AuditCategory} category
+   * @param {!Audits.AuditCategory} category
    */
   addCategory(category) {
     this.categoriesById[category.id] = category;
     this._launcherView.addCategory(category);
   }
 
   /**
    * @param {string} id
-   * @return {!WebInspector.AuditCategory}
+   * @return {!Audits.AuditCategory}
    */
   getCategory(id) {
     return this.categoriesById[id];
   }
 
   _constructCategories() {
     this._auditCategoriesById = {};
-    for (var categoryCtorID in WebInspector.AuditCategories) {
-      var auditCategory = new WebInspector.AuditCategories[categoryCtorID]();
+    for (var categoryCtorID in Audits.AuditCategories) {
+      var auditCategory = new Audits.AuditCategories[categoryCtorID]();
       auditCategory._id = categoryCtorID;
       this.categoriesById[categoryCtorID] = auditCategory;
     }
   }
 
   /**
    * @param {string} mainResourceURL
-   * @param {!Array.<!WebInspector.AuditCategoryResult>} results
+   * @param {!Array.<!Audits.AuditCategoryResult>} results
    */
   auditFinishedCallback(mainResourceURL, results) {
     var ordinal = 1;
     for (var child of this._auditResultsTreeElement.children()) {
       if (child.mainResourceURL === mainResourceURL)
         ordinal++;
     }
 
-    var resultTreeElement = new WebInspector.AuditResultSidebarTreeElement(this, results, mainResourceURL, ordinal);
+    var resultTreeElement = new Audits.AuditResultSidebarTreeElement(this, results, mainResourceURL, ordinal);
     this._auditResultsTreeElement.appendChild(resultTreeElement);
     resultTreeElement.revealAndSelect();
   }
 
   /**
-   * @param {!Array.<!WebInspector.AuditCategoryResult>} categoryResults
+   * @param {!Array.<!Audits.AuditCategoryResult>} categoryResults
    */
   showResults(categoryResults) {
     if (!categoryResults._resultLocation) {
       categoryResults.sort((a, b) => (a.title || '').localeCompare(b.title || ''));
-      var resultView = WebInspector.viewManager.createStackLocation();
+      var resultView = UI.viewManager.createStackLocation();
       resultView.widget().element.classList.add('audit-result-view');
       for (var i = 0; i < categoryResults.length; ++i)
-        resultView.showView(new WebInspector.AuditCategoryResultPane(categoryResults[i]));
+        resultView.showView(new Audits.AuditCategoryResultPane(categoryResults[i]));
       categoryResults._resultLocation = resultView;
     }
     this.visibleView = categoryResults._resultLocation.widget();
   }
 
   showLauncherView() {
     this.visibleView = this._launcherView;
   }
 
   get visibleView() {
@@ skipping 28 matching lines @@
   focus() {
     this._sidebarTree.focus();
   }
 
   clearResults() {
     this._auditsItemTreeElement.revealAndSelect();
     this._auditResultsTreeElement.removeChildren();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _extensionAuditCategoryAdded(event) {
-    var category = /** @type {!WebInspector.ExtensionAuditCategory} */ (event.data);
-    this.addCategory(new WebInspector.AuditExtensionCategory(
+    var category = /** @type {!Extensions.ExtensionAuditCategory} */ (event.data);
+    this.addCategory(new Audits.AuditExtensionCategory(
         category.extensionOrigin, category.id, category.displayName, category.ruleCount));
   }
 };
 
 /**
- * @implements {WebInspector.AuditCategory}
+ * @implements {Audits.AuditCategory}
  * @unrestricted
  */
-WebInspector.AuditCategoryImpl = class {
+Audits.AuditCategoryImpl = class {
   /**
    * @param {string} displayName
    */
   constructor(displayName) {
     this._displayName = displayName;
     this._rules = [];
   }
 
   /**
    * @override
    * @return {string}
    */
   get id() {
     // this._id value is injected at construction time.
     return this._id;
   }
 
   /**
    * @override
    * @return {string}
    */
   get displayName() {
     return this._displayName;
   }
 
   /**
-   * @param {!WebInspector.AuditRule} rule
-   * @param {!WebInspector.AuditRule.Severity} severity
+   * @param {!Audits.AuditRule} rule
+   * @param {!Audits.AuditRule.Severity} severity
    */
   addRule(rule, severity) {
     rule.severity = severity;
     this._rules.push(rule);
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
-   * @param {!Array.<!WebInspector.NetworkRequest>} requests
-   * @param {function(!WebInspector.AuditRuleResult)} ruleResultCallback
-   * @param {!WebInspector.Progress} progress
+   * @param {!SDK.Target} target
+   * @param {!Array.<!SDK.NetworkRequest>} requests
+   * @param {function(!Audits.AuditRuleResult)} ruleResultCallback
+   * @param {!Common.Progress} progress
    */
   run(target, requests, ruleResultCallback, progress) {
     this._ensureInitialized();
     var remainingRulesCount = this._rules.length;
     progress.setTotalWork(remainingRulesCount);
     function callbackWrapper(result) {
       ruleResultCallback(result);
       progress.worked();
       if (!--remainingRulesCount)
         progress.done();
@@ skipping 11 matching lines @@
       if ('initialize' in this)
         this.initialize();
       this._initialized = true;
     }
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AuditRule = class {
+Audits.AuditRule = class {
   /**
    * @param {string} id
    * @param {string} displayName
    */
   constructor(id, displayName) {
     this._id = id;
     this._displayName = displayName;
   }
 
   get id() {
     return this._id;
   }
 
   get displayName() {
     return this._displayName;
   }
 
   /**
-   * @param {!WebInspector.AuditRule.Severity} severity
+   * @param {!Audits.AuditRule.Severity} severity
    */
   set severity(severity) {
     this._severity = severity;
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!Array.<!WebInspector.NetworkRequest>} requests
-   * @param {function(?WebInspector.AuditRuleResult)} callback
-   * @param {!WebInspector.Progress} progress
+   * @param {!SDK.Target} target
+   * @param {!Array.<!SDK.NetworkRequest>} requests
+   * @param {function(?Audits.AuditRuleResult)} callback
+   * @param {!Common.Progress} progress
    */
   run(target, requests, callback, progress) {
     if (progress.isCanceled())
       return;
 
-    var result = new WebInspector.AuditRuleResult(this.displayName);
+    var result = new Audits.AuditRuleResult(this.displayName);
     result.severity = this._severity;
     this.doRun(target, requests, result, callback, progress);
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!Array.<!WebInspector.NetworkRequest>} requests
-   * @param {!WebInspector.AuditRuleResult} result
-   * @param {function(?WebInspector.AuditRuleResult)} callback
-   * @param {!WebInspector.Progress} progress
+   * @param {!SDK.Target} target
+   * @param {!Array.<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
+   * @param {function(?Audits.AuditRuleResult)} callback
+   * @param {!Common.Progress} progress
    */
   doRun(target, requests, result, callback, progress) {
     throw new Error('doRun() not implemented');
   }
 };
 
 /**
  * @enum {string}
  */
-WebInspector.AuditRule.Severity = {
+Audits.AuditRule.Severity = {
   Info: 'info',
   Warning: 'warning',
   Severe: 'severe'
 };
 
-WebInspector.AuditRule.SeverityOrder = {
+Audits.AuditRule.SeverityOrder = {
   'info': 3,
   'warning': 2,
   'severe': 1
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AuditCategoryResult = class {
+Audits.AuditCategoryResult = class {
   /**
-   * @param {!WebInspector.AuditCategory} category
+   * @param {!Audits.AuditCategory} category
    */
   constructor(category) {
     this.title = category.displayName;
     this.ruleResults = [];
   }
 
   /**
-   * @param {!WebInspector.AuditRuleResult} ruleResult
+   * @param {!Audits.AuditRuleResult} ruleResult
    */
   addRuleResult(ruleResult) {
     this.ruleResults.push(ruleResult);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AuditRuleResult = class {
+Audits.AuditRuleResult = class {
   /**
    * @param {(string|boolean|number|!Object)} value
    * @param {boolean=} expanded
    * @param {string=} className
    */
   constructor(value, expanded, className) {
     this.value = value;
     this.className = className;
     this.expanded = expanded;
     this.violationCount = 0;
-    this._formatters = {r: WebInspector.AuditRuleResult.linkifyDisplayName};
+    this._formatters = {r: Audits.AuditRuleResult.linkifyDisplayName};
     var standardFormatters = Object.keys(String.standardFormatters);
     for (var i = 0; i < standardFormatters.length; ++i)
       this._formatters[standardFormatters[i]] = String.standardFormatters[standardFormatters[i]];
   }
 
   /**
    * @param {string} url
    * @return {!Element}
    */
   static linkifyDisplayName(url) {
-    return WebInspector.linkifyURLAsNode(url, WebInspector.displayNameForURL(url));
+    return UI.linkifyURLAsNode(url, Bindings.displayNameForURL(url));
   }
 
   /**
    * @param {string} domain
    * @return {string}
    */
   static resourceDomain(domain) {
-    return domain || WebInspector.UIString('[empty domain]');
+    return domain || Common.UIString('[empty domain]');
   }
 
   /**
    * @param {(string|boolean|number|!Object)} value
    * @param {boolean=} expanded
    * @param {string=} className
-   * @return {!WebInspector.AuditRuleResult}
+   * @return {!Audits.AuditRuleResult}
    */
   addChild(value, expanded, className) {
     if (!this.children)
       this.children = [];
-    var entry = new WebInspector.AuditRuleResult(value, expanded, className);
+    var entry = new Audits.AuditRuleResult(value, expanded, className);
     this.children.push(entry);
     return entry;
   }
 
   /**
    * @param {string} url
    */
   addURL(url) {
-    this.addChild(WebInspector.AuditRuleResult.linkifyDisplayName(url));
+    this.addChild(Audits.AuditRuleResult.linkifyDisplayName(url));
   }
 
   /**
    * @param {!Array.<string>} urls
    */
   addURLs(urls) {
     for (var i = 0; i < urls.length; ++i)
       this.addURL(urls[i]);
   }
 
   /**
    * @param {string} snippet
    */
   addSnippet(snippet) {
     this.addChild(snippet, false, 'source-code');
   }
 
   /**
    * @param {string} format
    * @param {...*} vararg
-   * @return {!WebInspector.AuditRuleResult}
+   * @return {!Audits.AuditRuleResult}
    */
   addFormatted(format, vararg) {
     var substitutions = Array.prototype.slice.call(arguments, 1);
     var fragment = createDocumentFragment();
 
     function append(a, b) {
       if (!(b instanceof Node))
         b = createTextNode(b);
       a.appendChild(b);
       return a;
     }
 
     var formattedResult = String.format(format, substitutions, this._formatters, fragment, append).formattedResult;
     if (formattedResult instanceof Node)
       formattedResult.normalize();
     return this.addChild(formattedResult);
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.AuditsSidebarTreeElement = class extends TreeElement {
+Audits.AuditsSidebarTreeElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.AuditsPanel} panel
+   * @param {!Audits.AuditsPanel} panel
    */
   constructor(panel) {
-    super(WebInspector.UIString('Audits'), false);
+    super(Common.UIString('Audits'), false);
     this.selectable = true;
     this._panel = panel;
     this.listItemElement.classList.add('audits-sidebar-header');
     this.listItemElement.insertBefore(createElementWithClass('div', 'icon'), this.listItemElement.firstChild);
   }
 
   /**
    * @override
    * @return {boolean}
    */
   onselect() {
     this._panel.showLauncherView();
     return true;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AuditResultSidebarTreeElement = class extends TreeElement {
+Audits.AuditResultSidebarTreeElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.AuditsPanel} panel
-   * @param {!Array.<!WebInspector.AuditCategoryResult>} results
+   * @param {!Audits.AuditsPanel} panel
+   * @param {!Array.<!Audits.AuditCategoryResult>} results
    * @param {string} mainResourceURL
    * @param {number} ordinal
    */
   constructor(panel, results, mainResourceURL, ordinal) {
     super(String.sprintf('%s (%d)', mainResourceURL, ordinal), false);
     this.selectable = true;
     this._panel = panel;
     this.results = results;
     this.mainResourceURL = mainResourceURL;
     this.listItemElement.classList.add('audit-result-sidebar-tree-item');
     this.listItemElement.insertBefore(createElementWithClass('div', 'icon'), this.listItemElement.firstChild);
   }
 
   /**
    * @override
    * @return {boolean}
    */
   onselect() {
     this._panel.showResults(this.results);
     return true;
   }
 };
 
 
 // Contributed audit rules should go into this namespace.
-WebInspector.AuditRules = {};
+Audits.AuditRules = {};
 
 /**
  * Contributed audit categories should go into this namespace.
- * @type {!Object.<string, function(new:WebInspector.AuditCategory)>}
+ * @type {!Object.<string, function(new:Audits.AuditCategory)>}
  */
-WebInspector.AuditCategories = {};
+Audits.AuditCategories = {};