DevTools: use semicolons after each statement.

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 46 matching lines @@
     this._launcherView = new WebInspector.AuditLauncherView(this._auditController);
     for (var id in this.categoriesById)
         this._launcherView.addCategory(this.categoriesById[id]);
 
     var extensionCategories = WebInspector.extensionServer.auditCategories();
     for (var i = 0; i < extensionCategories.length; ++i) {
         var category = extensionCategories[i];
         this.addCategory(new WebInspector.AuditExtensionCategory(category.extensionOrigin, category.id, category.displayName, category.ruleCount));
     }
     WebInspector.extensionServer.addEventListener(WebInspector.ExtensionServer.Events.AuditCategoryAdded, this._extensionAuditCategoryAdded, this);
-}
+};
 
 WebInspector.AuditsPanel.prototype = {
 
     /**
      * @return {!Object.<string, !WebInspector.AuditCategory>}
      */
     get categoriesById()
     {
         return this._auditCategoriesById;
     },
@@ skipping 107 matching lines @@
     /**
      * @param {!WebInspector.Event} event
      */
     _extensionAuditCategoryAdded: function(event)
     {
         var category = /** @type {!WebInspector.ExtensionAuditCategory} */ (event.data);
         this.addCategory(new WebInspector.AuditExtensionCategory(category.extensionOrigin, category.id, category.displayName, category.ruleCount));
     },
 
     __proto__: WebInspector.PanelWithSidebar.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.AuditCategory}
  * @param {string} displayName
  */
 WebInspector.AuditCategoryImpl = function(displayName)
 {
     this._displayName = displayName;
     this._rules = [];
-}
+};
 
 WebInspector.AuditCategoryImpl.prototype = {
     /**
      * @override
      * @return {string}
      */
     get id()
     {
         // this._id value is injected at construction time.
         return this._id;
@@ skipping 46 matching lines @@
     },
 
     _ensureInitialized: function()
     {
         if (!this._initialized) {
             if ("initialize" in this)
                 this.initialize();
             this._initialized = true;
         }
     }
-}
+};
 
 /**
  * @constructor
  * @param {string} id
  * @param {string} displayName
  */
 WebInspector.AuditRule = function(id, displayName)
 {
     this._id = id;
     this._displayName = displayName;
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.AuditRule.Severity = {
     Info: "info",
     Warning: "warning",
     Severe: "severe"
-}
+};
 
 WebInspector.AuditRule.SeverityOrder = {
     "info": 3,
     "warning": 2,
     "severe": 1
-}
+};
 
 WebInspector.AuditRule.prototype = {
     get id()
     {
         return this._id;
     },
 
     get displayName()
     {
         return this._displayName;
@@ skipping 27 matching lines @@
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
     doRun: function(target, requests, result, callback, progress)
     {
         throw new Error("doRun() not implemented");
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.AuditCategory} category
  */
 WebInspector.AuditCategoryResult = function(category)
 {
     this.title = category.displayName;
     this.ruleResults = [];
-}
+};
 
 WebInspector.AuditCategoryResult.prototype = {
     /**
      * @param {!WebInspector.AuditRuleResult} ruleResult
      */
     addRuleResult: function(ruleResult)
     {
         this.ruleResults.push(ruleResult);
     }
-}
+};
 
 /**
  * @constructor
  * @param {(string|boolean|number|!Object)} value
  * @param {boolean=} expanded
  * @param {string=} className
  */
 WebInspector.AuditRuleResult = function(value, expanded, className)
 {
     this.value = value;
     this.className = className;
     this.expanded = expanded;
     this.violationCount = 0;
     this._formatters = {
         r: WebInspector.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}
  */
 WebInspector.AuditRuleResult.linkifyDisplayName = function(url)
 {
     return WebInspector.linkifyURLAsNode(url, WebInspector.displayNameForURL(url));
-}
+};
 
 /**
  * @param {string} domain
  * @return {string}
  */
 WebInspector.AuditRuleResult.resourceDomain = function(domain)
 {
     return domain || WebInspector.UIString("[empty domain]");
-}
+};
 
 WebInspector.AuditRuleResult.prototype = {
     /**
      * @param {(string|boolean|number|!Object)} value
      * @param {boolean=} expanded
      * @param {string=} className
      * @return {!WebInspector.AuditRuleResult}
      */
     addChild: function(value, expanded, className)
     {
@@ skipping 45 matching lines @@
                 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);
     }
-}
+};
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.AuditsPanel} panel
  */
 WebInspector.AuditsSidebarTreeElement = function(panel)
 {
     TreeElement.call(this, WebInspector.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);
-}
+};
 
 WebInspector.AuditsSidebarTreeElement.prototype = {
     /**
      * @override
      * @return {boolean}
      */
     onselect: function()
     {
         this._panel.showLauncherView();
         return true;
     },
 
     __proto__: TreeElement.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.AuditsPanel} panel
  * @param {!Array.<!WebInspector.AuditCategoryResult>} results
  * @param {string} mainResourceURL
  * @param {number} ordinal
  */
 WebInspector.AuditResultSidebarTreeElement = function(panel, results, mainResourceURL, ordinal)
 {
     TreeElement.call(this, 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);
-}
+};
 
 WebInspector.AuditResultSidebarTreeElement.prototype = {
     /**
      * @override
      * @return {boolean}
      */
     onselect: function()
     {
         this._panel.showResults(this.results);
         return true;
     },
 
     __proto__: TreeElement.prototype
-}
+};
 
 /**
  * @return {!WebInspector.AuditsPanel}
  */
 WebInspector.AuditsPanel.instance = function()
 {
     return /** @type {!WebInspector.AuditsPanel} */ (self.runtime.sharedInstance(WebInspector.AuditsPanel));
-}
+};
 
 // Contributed audit rules should go into this namespace.
 WebInspector.AuditRules = {};
 
 /**
  * Contributed audit categories should go into this namespace.
  * @type {!Object.<string, function(new:WebInspector.AuditCategory)>}
  */
 WebInspector.AuditCategories = {};