DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/audits/AuditRules.js

 /*
  * Copyright (C) 2010 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 22 matching lines @@
 WebInspector.AuditRules.CacheableResponseCodes =
 {
     200: true,
     203: true,
     206: true,
     300: true,
     301: true,
     410: true,
 
     304: true // Underlying request is cacheable
-}
+};
 
 /**
  * @param {!Array.<!WebInspector.NetworkRequest>} requests
  * @param {?Array.<!WebInspector.ResourceType>} types
  * @param {boolean} needFullResources
  * @return {!Object.<string, !Array.<!WebInspector.NetworkRequest|string>>}
  */
 WebInspector.AuditRules.getDomainToResourcesMap = function(requests, types, needFullResources)
 {
     var domainToResourcesMap = {};
     for (var i = 0, size = requests.length; i < size; ++i) {
         var request = requests[i];
         if (types && types.indexOf(request.resourceType()) === -1)
             continue;
         var parsedURL = request.url.asParsedURL();
         if (!parsedURL)
             continue;
         var domain = parsedURL.host;
         var domainResources = domainToResourcesMap[domain];
         if (domainResources === undefined) {
             domainResources = [];
             domainToResourcesMap[domain] = domainResources;
         }
         domainResources.push(needFullResources ? request : request.url);
     }
     return domainToResourcesMap;
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.GzipRule = function()
 {
     WebInspector.AuditRule.call(this, "network-gzip", WebInspector.UIString("Enable gzip compression"));
-}
+};
 
 WebInspector.AuditRules.GzipRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 42 matching lines @@
 
     /**
      * @param {!WebInspector.NetworkRequest} request
      */
     _shouldCompress: function(request)
     {
         return request.resourceType().isTextType() && request.parsedURL.host && request.resourceSize !== undefined && request.resourceSize > 150;
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  * @param {string} id
  * @param {string} name
  * @param {!WebInspector.ResourceType} type
  * @param {string} resourceTypeName
  * @param {boolean} allowedPerDomain
  */
 WebInspector.AuditRules.CombineExternalResourcesRule = function(id, name, type, resourceTypeName, allowedPerDomain)
 {
     WebInspector.AuditRule.call(this, id, name);
     this._type = type;
     this._resourceTypeName = resourceTypeName;
     this._allowedPerDomain = allowedPerDomain;
-}
+};
 
 WebInspector.AuditRules.CombineExternalResourcesRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 15 matching lines @@
         if (!penalizedResourceCount) {
             callback(null);
             return;
         }
 
         summary.value = WebInspector.UIString("There are multiple resources served from same domain. Consider combining them into as few files as possible.");
         callback(result);
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRules.CombineExternalResourcesRule}
  */
 WebInspector.AuditRules.CombineJsResourcesRule = function(allowedPerDomain) {
     WebInspector.AuditRules.CombineExternalResourcesRule.call(this, "page-externaljs", WebInspector.UIString("Combine external JavaScript"), WebInspector.resourceTypes.Script, "JavaScript", allowedPerDomain);
-}
+};
 
 WebInspector.AuditRules.CombineJsResourcesRule.prototype = {
     __proto__: WebInspector.AuditRules.CombineExternalResourcesRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRules.CombineExternalResourcesRule}
  */
 WebInspector.AuditRules.CombineCssResourcesRule = function(allowedPerDomain) {
     WebInspector.AuditRules.CombineExternalResourcesRule.call(this, "page-externalcss", WebInspector.UIString("Combine external CSS"), WebInspector.resourceTypes.Stylesheet, "CSS", allowedPerDomain);
-}
+};
 
 WebInspector.AuditRules.CombineCssResourcesRule.prototype = {
     __proto__: WebInspector.AuditRules.CombineExternalResourcesRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.MinimizeDnsLookupsRule = function(hostCountThreshold) {
     WebInspector.AuditRule.call(this, "network-minimizelookups", WebInspector.UIString("Minimize DNS lookups"));
     this._hostCountThreshold = hostCountThreshold;
-}
+};
 
 WebInspector.AuditRules.MinimizeDnsLookupsRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 15 matching lines @@
         if (!summary.children || summary.children.length <= this._hostCountThreshold) {
             callback(null);
             return;
         }
 
         summary.value = WebInspector.UIString("The following domains only serve one resource each. If possible, avoid the extra DNS lookups by serving these resources from existing domains.");
         callback(result);
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.ParallelizeDownloadRule = function(optimalHostnameCount, minRequestThreshold, minBalanceThreshold)
 {
     WebInspector.AuditRule.call(this, "network-parallelizehosts", WebInspector.UIString("Parallelize downloads across hostnames"));
     this._optimalHostnameCount = optimalHostnameCount;
     this._minRequestThreshold = minRequestThreshold;
     this._minBalanceThreshold = minBalanceThreshold;
-}
+};
 
 WebInspector.AuditRules.ParallelizeDownloadRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 55 matching lines @@
         var requestsOnBusiestHost = domainToResourcesMap[hosts[0]];
         var entry = result.addChild(WebInspector.UIString("This page makes %d parallelizable requests to %s. Increase download parallelization by distributing the following requests across multiple hostnames.", busiestHostResourceCount, hosts[0]), true);
         for (var i = 0; i < requestsOnBusiestHost.length; ++i)
             entry.addURL(requestsOnBusiestHost[i].url);
 
         result.violationCount = requestsOnBusiestHost.length;
         callback(result);
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * The reported CSS rule size is incorrect (parsed != original in WebKit),
  * so use percentages instead, which gives a better approximation.
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.UnusedCssRule = function()
 {
     WebInspector.AuditRule.call(this, "page-unusedcss", WebInspector.UIString("Remove unused CSS rules"));
-}
+};
 
 WebInspector.AuditRules.UnusedCssRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 120 matching lines @@
         var styleSheetInfos = cssModel.allStyleSheets();
         if (!styleSheetInfos || !styleSheetInfos.length) {
             evalCallback([]);
             return;
         }
         var styleSheetProcessor = new WebInspector.AuditRules.StyleSheetProcessor(styleSheetInfos, progress, evalCallback);
         styleSheetProcessor.run();
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @typedef {!{sourceURL: string, rules: !Array.<!WebInspector.CSSParser.StyleRule>}}
  */
 WebInspector.AuditRules.ParsedStyleSheet;
 
 /**
  * @constructor
  * @param {!Array.<!WebInspector.CSSStyleSheetHeader>} styleSheetHeaders
  * @param {!WebInspector.Progress} progress
  * @param {function(!Array.<!WebInspector.AuditRules.ParsedStyleSheet>)} styleSheetsParsedCallback
  */
 WebInspector.AuditRules.StyleSheetProcessor = function(styleSheetHeaders, progress, styleSheetsParsedCallback)
 {
     this._styleSheetHeaders = styleSheetHeaders;
     this._progress = progress;
     this._styleSheets = [];
     this._styleSheetsParsedCallback = styleSheetsParsedCallback;
-}
+};
 
 WebInspector.AuditRules.StyleSheetProcessor.prototype = {
     run: function()
     {
         this._parser = new WebInspector.CSSParser();
         this._processNextStyleSheet();
     },
 
     _terminateWorker: function()
     {
@@ skipping 34 matching lines @@
             var rule = rules[i];
             if (rule.selectorText)
                 styleRules.push(rule);
         }
         this._styleSheets.push({
             sourceURL: this._currentStyleSheetHeader.sourceURL,
             rules: styleRules
         });
         this._processNextStyleSheet();
     },
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.CacheControlRule = function(id, name)
 {
     WebInspector.AuditRule.call(this, id, name);
-}
+};
 
 WebInspector.AuditRules.CacheControlRule.MillisPerMonth = 1000 * 60 * 60 * 24 * 30;
 
 WebInspector.AuditRules.CacheControlRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(!WebInspector.AuditRuleResult)} callback
@@ skipping 159 matching lines @@
     /**
      * @param {!WebInspector.NetworkRequest} request
      * @return {boolean}
      */
     isCacheableResource: function(request)
     {
         return request.statusCode !== undefined && WebInspector.AuditRules.CacheableResponseCodes[request.statusCode];
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRules.CacheControlRule}
  */
 WebInspector.AuditRules.BrowserCacheControlRule = function()
 {
     WebInspector.AuditRules.CacheControlRule.call(this, "http-browsercache", WebInspector.UIString("Leverage browser caching"));
-}
+};
 
 WebInspector.AuditRules.BrowserCacheControlRule.prototype = {
     handleNonCacheableResources: function(requests, result)
     {
         if (requests.length) {
             var entry = result.addChild(WebInspector.UIString("The following resources are explicitly non-cacheable. Consider making them cacheable if possible:"), true);
             result.violationCount += requests.length;
             for (var i = 0; i < requests.length; ++i)
                 entry.addURL(requests[i].url);
         }
@@ skipping 39 matching lines @@
 
     _oneYearExpirationCheck: function(request)
     {
         return this.isCacheableResource(request) &&
             !this.hasResponseHeader(request, "Set-Cookie") &&
             !this.freshnessLifetimeGreaterThan(request, 11 * WebInspector.AuditRules.CacheControlRule.MillisPerMonth) &&
             this.freshnessLifetimeGreaterThan(request, WebInspector.AuditRules.CacheControlRule.MillisPerMonth);
     },
 
     __proto__: WebInspector.AuditRules.CacheControlRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.ImageDimensionsRule = function()
 {
     WebInspector.AuditRule.call(this, "page-imagedims", WebInspector.UIString("Specify image dimensions"));
-}
+};
 
 WebInspector.AuditRules.ImageDimensionsRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 118 matching lines @@
         }
 
         if (progress.isCanceled()) {
             callback(null);
             return;
         }
         domModel.requestDocument(onDocumentAvailable);
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.CssInHeadRule = function()
 {
     WebInspector.AuditRule.call(this, "page-cssinhead", WebInspector.UIString("Put CSS in the document head"));
-}
+};
 
 WebInspector.AuditRules.CssInHeadRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 87 matching lines @@
                 return;
             }
 
             domModel.querySelectorAll(root.id, "body style", inlineStylesReceived.bind(null, root));
         }
 
         domModel.requestDocument(onDocumentAvailable);
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.StylesScriptsOrderRule = function()
 {
     WebInspector.AuditRule.call(this, "page-stylescriptorder", WebInspector.UIString("Optimize the order of styles and scripts"));
-}
+};
 
 WebInspector.AuditRules.StylesScriptsOrderRule.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 87 matching lines @@
                 return;
             }
 
             domModel.querySelectorAll(root.id, "head script[src] ~ link[rel~='stylesheet'][href]", lateStylesReceived.bind(null, root));
         }
 
         domModel.requestDocument(onDocumentAvailable);
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.CSSRuleBase = function(id, name)
 {
     WebInspector.AuditRule.call(this, id, name);
-}
+};
 
 WebInspector.AuditRules.CSSRuleBase.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(?WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 104 matching lines @@
      * @param {!WebInspector.CSSParser.StyleRule} rule
      * @param {!WebInspector.CSSParser.Property} property
      * @param {!WebInspector.AuditRuleResult} result
      */
     visitProperty: function(styleSheet, rule, property, result)
     {
         // Subclasses can implement.
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRule}
  */
 WebInspector.AuditRules.CookieRuleBase = function(id, name)
 {
     WebInspector.AuditRule.call(this, id, name);
-}
+};
 
 WebInspector.AuditRules.CookieRuleBase.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      * @param {!Array.<!WebInspector.NetworkRequest>} requests
      * @param {!WebInspector.AuditRuleResult} result
      * @param {function(!WebInspector.AuditRuleResult)} callback
      * @param {!WebInspector.Progress} progress
      */
@@ skipping 28 matching lines @@
     {
         if (!requests)
             return;
         for (var i = 0; i < requests.length; ++i) {
             if (WebInspector.Cookies.cookieMatchesResourceURL(cookie, requests[i].url))
                 callback(requests[i], cookie);
         }
     },
 
     __proto__: WebInspector.AuditRule.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRules.CookieRuleBase}
  */
 WebInspector.AuditRules.CookieSizeRule = function(avgBytesThreshold)
 {
     WebInspector.AuditRules.CookieRuleBase.call(this, "http-cookiesize", WebInspector.UIString("Minimize cookie size"));
     this._avgBytesThreshold = avgBytesThreshold;
     this._maxBytesThreshold = 1000;
-}
+};
 
 WebInspector.AuditRules.CookieSizeRule.prototype = {
     _average: function(cookieArray)
     {
         var total = 0;
         for (var i = 0; i < cookieArray.length; ++i)
             total += cookieArray[i].size();
         return cookieArray.length ? Math.round(total / cookieArray.length) : 0;
     },
 
@@ skipping 75 matching lines @@
         }
 
         if (bigAvgCookieDomains.length) {
             var entry = result.addChild(WebInspector.UIString("The following domains have an average cookie size in excess of %d bytes. Reducing the size of cookies for these domains can reduce the time it takes to send requests.", this._avgBytesThreshold), true);
             entry.addURLs(bigAvgCookieDomains);
             result.violationCount += bigAvgCookieDomains.length;
         }
     },
 
     __proto__: WebInspector.AuditRules.CookieRuleBase.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.AuditRules.CookieRuleBase}
  */
 WebInspector.AuditRules.StaticCookielessRule = function(minResources)
 {
     WebInspector.AuditRules.CookieRuleBase.call(this, "http-staticcookieless", WebInspector.UIString("Serve static content from a cookieless domain"));
     this._minResources = minResources;
-}
+};
 
 WebInspector.AuditRules.StaticCookielessRule.prototype = {
     processCookies: function(allCookies, requests, result)
     {
         var domainToResourcesMap = WebInspector.AuditRules.getDomainToResourcesMap(requests,
                 [WebInspector.resourceTypes.Stylesheet,
                  WebInspector.resourceTypes.Image],
                 true);
         var totalStaticResources = 0;
         for (var domain in domainToResourcesMap)
@@ skipping 16 matching lines @@
         entry.addURLs(badUrls);
         result.violationCount = badUrls.length;
     },
 
     _collectorCallback: function(matchingResourceData, request, cookie)
     {
         matchingResourceData[request.url] = (matchingResourceData[request.url] || 0) + cookie.size();
     },
 
     __proto__: WebInspector.AuditRules.CookieRuleBase.prototype
-}
+};