[Devtools] Fixed url in Audits and added doctypes

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 11 matching lines @@
  * OWNER 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.
  */
 Audits.AuditRules.IPAddressRegexp = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
 
+/** @type {!Object<number, boolean>} */
 Audits.AuditRules.CacheableResponseCodes = {
   200: true,
   203: true,
   206: true,
   300: true,
   301: true,
   410: true,
 
   304: true  // Underlying request is cacheable
 };
 
 /**
- * @param {!Array.<!SDK.NetworkRequest>} requests
- * @param {?Array.<!Common.ResourceType>} types
- * @param {boolean} needFullResources
- * @return {!Object.<string, !Array.<!SDK.NetworkRequest|string>>}
+ * @param {!Array<!SDK.NetworkRequest>} requests
+ * @param {?Array<!Common.ResourceType>} types
+ * @return {!Object<string, !Array<!SDK.NetworkRequest>>}
  */
-Audits.AuditRules.getDomainToResourcesMap = function(requests, types, needFullResources) {
-  /** @type {!Object<string, !Array<!SDK.NetworkRequest|string>>} */
+Audits.AuditRules.getDomainToResourcesMap = function(requests, types) {
+  /** @type {!Object<string, !Array<!SDK.NetworkRequest>>} */
   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 = /** @type {!Array<!SDK.NetworkRequest|string>} */ ([]);
+      domainResources = /** @type {!Array<!SDK.NetworkRequest>} */ ([]);
       domainToResourcesMap[domain] = domainResources;
     }
-    domainResources.push(needFullResources ? request : request.url());
+    domainResources.push(request);
   }
   return domainToResourcesMap;
 };
 
 /**
+ * @param {!Array<!SDK.NetworkRequest>} requests
+ * @param {?Array<!Common.ResourceType>} types
+ * @return {!Object<string, !Array<string>>}
+ */
+Audits.AuditRules.getDomainToResourceUrlMap = function(requests, types) {

[luoe, 2017/01/13 08:05:22]

I don't think this new function is needed.  The places where it is used (lines
174, 241) only access the domain and get the length of the domain's requests
array.  Nothing seems to use the actual url's.

[allada, 2017/01/17 19:16:25]

line: 245 does.

[luoe, 2017/01/17 19:40:16]

Line 245 is using "domain", the keys of the map, not the urls in the values. 
The values "domainToResourcesMap[domain]" is never used besides getting its
length.

[allada, 2017/01/17 19:50:11]

Done.

+  var requestMap = Audits.AuditRules.getDomainToResourcesMap(requests, types);
+  /** @type {!Object<string, !Array<string>>} */
+  var output = {};

[alph, 2017/01/12 07:54:42]

nit: can you plz use Map as assigning arbitrary keys to an object is not a good
idea.

[allada, 2017/01/12 23:49:31]

I don't want to do this because this patch is not to refactor anything it's only
to get stuff typed. I separated these two functions because it was one function
with two different output types. I simply separated the single function into two
functions.

+  for (var domain of Object.keys(requestMap))
+    output[domain] = requestMap[domain].map(request => request.url());
+  return output;
+};
+
+/**
  * @unrestricted
  */
 Audits.AuditRules.GzipRule = class extends Audits.AuditRule {
   constructor() {
     super('network-gzip', Common.UIString('Enable gzip compression'));
   }
 
   /**
    * @override
    * @param {!SDK.Target} target
    * @param {!Array.<!SDK.NetworkRequest>} requests

[luoe, 2017/01/13 08:05:22]

Remove period here and in all the places where there's ".<"

[allada, 2017/01/17 19:16:25]

This patch isn't here to fix legacy doctypes.

    * @param {!Audits.AuditRuleResult} result
    * @param {function(?Audits.AuditRuleResult)} callback
    * @param {!Common.Progress} progress
    */
   doRun(target, requests, result, callback, progress) {
     var totalSavings = 0;
     var summary = result.addChild('', true);
     for (var i = 0, length = requests.length; i < length; ++i) {
       var request = requests[i];
       if (request.cached() || request.statusCode === 304)
@@ skipping 12 matching lines @@
       callback(null);
       return;
     }
     summary.value = Common.UIString(
         'Compressing the following resources with gzip could reduce their transfer size by about two thirds (~%s):',
         Number.bytesToString(totalSavings));
     callback(result);
   }
 
   /**
    * @param {!SDK.NetworkRequest} request

[luoe, 2017/01/13 08:05:22]

Missing @return here and in many other functions

[allada, 2017/01/17 19:16:25]

This patch isn't here to fix legacy doctypes.

    */
   _isCompressed(request) {
     var encodingHeader = request.responseHeaderValue('Content-Encoding');
     if (!encodingHeader)
       return false;
 
     return /\b(?:gzip|deflate)\b/.test(encodingHeader);
   }
 
   /**
@@ skipping 25 matching lines @@
 
   /**
    * @override
    * @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) {
-    var domainToResourcesMap = Audits.AuditRules.getDomainToResourcesMap(requests, [this._type], false);
+    var domainToResourcesMap = Audits.AuditRules.getDomainToResourceUrlMap(requests, [this._type]);
     var penalizedResourceCount = 0;
     // TODO: refactor according to the chosen i18n approach
     var summary = result.addChild('', true);
     for (var domain in domainToResourcesMap) {
       var domainResources = domainToResourcesMap[domain];
       var extraResourceCount = domainResources.length - this._allowedPerDomain;
       if (extraResourceCount <= 0)
         continue;
       penalizedResourceCount += extraResourceCount - 1;
       summary.addChild(Common.UIString(
@@ skipping 46 matching lines @@
   /**
    * @override
    * @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) {
     var summary = result.addChild('');
-    var domainToResourcesMap = Audits.AuditRules.getDomainToResourcesMap(requests, null, false);
+    var domainToResourcesMap = Audits.AuditRules.getDomainToResourceUrlMap(requests, null);
     for (var domain in domainToResourcesMap) {
       if (domainToResourcesMap[domain].length > 1)
         continue;
       var parsedURL = domain.asParsedURL();
       if (!parsedURL)
         continue;
       if (!parsedURL.host.search(Audits.AuditRules.IPAddressRegexp))
         continue;  // an IP address
       summary.addSnippet(domain);
       result.violationCount++;
@@ skipping 33 matching lines @@
      * @param {string} a
      * @param {string} b
      */
     function hostSorter(a, b) {
       var aCount = domainToResourcesMap[a].length;
       var bCount = domainToResourcesMap[b].length;
       return (aCount < bCount) ? 1 : (aCount === bCount) ? 0 : -1;
     }
 
     var domainToResourcesMap = Audits.AuditRules.getDomainToResourcesMap(
-        requests, [Common.resourceTypes.Stylesheet, Common.resourceTypes.Image], true);
+        requests, [Common.resourceTypes.Stylesheet, Common.resourceTypes.Image]);
 
+    /** @type {!Array<string>} */
     var hosts = [];
     for (var url in domainToResourcesMap)
       hosts.push(url);
 
     if (!hosts.length) {
       callback(null);  // no hosts (local file or something)
       return;
     }
 
     hosts.sort(hostSorter);
@@ skipping 66 matching lines @@
       return;
     }
 
     /**
      * @param {!Array.<!Audits.AuditRules.ParsedStyleSheet>} styleSheets
      */
     function evalCallback(styleSheets) {
       if (!styleSheets.length)
         return callback(null);
 
+      /** @type {!Array<string>} */
       var selectors = [];
+      /** @type {!Object<string, number>} */
       var testedSelectors = {};
       for (var i = 0; i < styleSheets.length; ++i) {
         var styleSheet = styleSheets[i];
         for (var curRule = 0; curRule < styleSheet.rules.length; ++curRule) {
           var selectorText = styleSheet.rules[curRule].selectorText;
           if (testedSelectors[selectorText])
             continue;
           selectors.push(selectorText);
           testedSelectors[selectorText] = 1;
         }
       }
 
+      /** @type {!Object<string, boolean>} */
       var foundSelectors = {};
 
       /**
        * @param {!Array.<!Audits.AuditRules.ParsedStyleSheet>} styleSheets
        */
       function selectorsCallback(styleSheets) {
         if (progress.isCanceled()) {
           callback(null);
           return;
         }
 
         var inlineBlockOrdinal = 0;
         var totalStylesheetSize = 0;
         var totalUnusedStylesheetSize = 0;
         var summary;
 
         for (var i = 0; i < styleSheets.length; ++i) {
           var styleSheet = styleSheets[i];
+          /** @type {!Array<string>} */
           var unusedRules = [];
           for (var curRule = 0; curRule < styleSheet.rules.length; ++curRule) {
             var rule = styleSheet.rules[curRule];
             if (!testedSelectors[rule.selectorText] || foundSelectors[rule.selectorText])
               continue;
             unusedRules.push(rule.selectorText);
           }
           totalStylesheetSize += styleSheet.rules.length;
           totalUnusedStylesheetSize += unusedRules.length;
 
@@ skipping 84 matching lines @@
  */
 Audits.AuditRules.StyleSheetProcessor = class {
   /**
    * @param {!Array.<!SDK.CSSStyleSheetHeader>} styleSheetHeaders
    * @param {!Common.Progress} progress
    * @param {function(!Array.<!Audits.AuditRules.ParsedStyleSheet>)} styleSheetsParsedCallback
    */
   constructor(styleSheetHeaders, progress, styleSheetsParsedCallback) {
     this._styleSheetHeaders = styleSheetHeaders;
     this._progress = progress;
+    /** @type {!Array<!Audits.AuditRules.ParsedStyleSheet>} */
     this._styleSheets = [];
     this._styleSheetsParsedCallback = styleSheetsParsedCallback;
   }
 
   run() {
     this._processNextStyleSheet();
   }
 
   _processNextStyleSheet() {
     if (!this._styleSheetHeaders.length) {
       this._styleSheetsParsedCallback(this._styleSheets);
       return;
     }
     this._currentStyleSheetHeader = this._styleSheetHeaders.shift();
 
+    /** @type {!Array<!Common.FormatterWorkerPool.CSSRule>} */
     var allRules = [];
     this._currentStyleSheetHeader.requestContent().then(
         content => Common.formatterWorkerPool.parseCSS(content || '', onRulesParsed.bind(this)));
 
     /**
      * @param {boolean} isLastChunk
      * @param {!Array<!Common.FormatterWorkerPool.CSSRule>} rules
      * @this {Audits.AuditRules.StyleSheetProcessor}
      */
     function onRulesParsed(isLastChunk, rules) {
-      allRules.push(...rules);
+      allRules.push.apply(allRules, rules);

[luoe, 2017/01/13 08:05:21]

I'm not sure how large the "rules" array gets, but apply with too many items may
fail.  Perhaps just for loop here?

[allada, 2017/01/17 19:16:25]

Apply is better per kozyatinskiy@

       if (isLastChunk)
         this._onStyleSheetParsed(allRules);
     }
   }
 
   /**
    * @param {!Array.<!Common.FormatterWorkerPool.CSSRule>} rules
    */
   _onStyleSheetParsed(rules) {
     if (this._progress.isCanceled()) {
       this._styleSheetsParsedCallback(this._styleSheets);
       return;
     }
 
+    /** @type {!Array<!Common.FormatterWorkerPool.CSSRule>} */
     var styleRules = [];
     for (var i = 0; i < rules.length; ++i) {
       var rule = rules[i];
       if (rule.selectorText)
         styleRules.push(rule);
     }
     this._styleSheets.push({sourceURL: this._currentStyleSheetHeader.sourceURL, rules: styleRules});
     this._processNextStyleSheet();
   }
 };
@@ skipping 16 matching lines @@
    */
   doRun(target, requests, result, callback, progress) {
     var cacheableAndNonCacheableResources = this._cacheableAndNonCacheableResources(requests);
     if (cacheableAndNonCacheableResources[0].length)
       this.runChecks(cacheableAndNonCacheableResources[0], result);
     this.handleNonCacheableResources(cacheableAndNonCacheableResources[1], result);
 
     callback(result);
   }
 
+  /**
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
+   */
   handleNonCacheableResources(requests, result) {
   }
 
+  /**
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @return {!Array<!Array<!SDK.NetworkRequest>>}
+   */
   _cacheableAndNonCacheableResources(requests) {
+    /** @type {!Array<!Array<!SDK.NetworkRequest>>} */
     var processedResources = [[], []];
     for (var i = 0; i < requests.length; ++i) {
       var request = requests[i];
       if (!this.isCacheableResource(request))
         continue;
       if (this._isExplicitlyNonCacheable(request))
         processedResources[1].push(request);
       else
         processedResources[0].push(request);
     }
     return processedResources;
   }
 
+  /**
+   * @param {string} messageText
+   * @param {function(!SDK.NetworkRequest):boolean} requestCheckFunction
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
+   */
   execCheck(messageText, requestCheckFunction, requests, result) {
     var requestCount = requests.length;
+    /** @type {!Array<string>} */
     var urls = [];
     for (var i = 0; i < requestCount; ++i) {
       if (requestCheckFunction.call(this, requests[i]))
-        urls.push(requests[i].url);
+        urls.push(requests[i].url());
     }
     if (urls.length) {
       var entry = result.addChild(messageText, true);
       entry.addURLs(urls);
       result.violationCount += urls.length;
     }
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
@@ skipping 114 matching lines @@
 /**
  * @unrestricted
  */
 Audits.AuditRules.BrowserCacheControlRule = class extends Audits.AuditRules.CacheControlRule {
   constructor() {
     super('http-browsercache', Common.UIString('Leverage browser caching'));
   }
 
   /**
    * @override
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
    */
   handleNonCacheableResources(requests, result) {
     if (requests.length) {
       var entry = result.addChild(
           Common.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);
+        entry.addURL(requests[i].url());
     }
   }
 
-  runChecks(requests, result, callback) {
+  /**
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
+   */
+  runChecks(requests, result) {
     this.execCheck(
         Common.UIString(
             'The following resources are missing a cache expiration. Resources that do not specify an expiration may not be cached by browsers:'),
         this._missingExpirationCheck, requests, result);
     this.execCheck(
         Common.UIString(
             'The following resources specify a "Vary" header that disables caching in most versions of Internet Explorer:'),
         this._varyCheck, requests, result);
     this.execCheck(
         Common.UIString('The following cacheable resources have a short freshness lifetime:'),
         this._oneMonthExpirationCheck, requests, result);
 
     // Unable to implement the favicon check due to the WebKit limitations.
     this.execCheck(
         Common.UIString(
             'To further improve cache hit rate, specify an expiration one year in the future for the following cacheable resources:'),
         this._oneYearExpirationCheck, requests, result);
   }
 
+  /**
+   * @param {!SDK.NetworkRequest} request
+   * @return {boolean}
+   */
   _missingExpirationCheck(request) {
     return this.isCacheableResource(request) && !this.hasResponseHeader(request, 'Set-Cookie') &&
         !this.hasExplicitExpiration(request);
   }
 
+  /**
+   * @param {!SDK.NetworkRequest} request
+   * @return {boolean}
+   */
   _varyCheck(request) {
     var varyHeader = this.responseHeader(request, 'Vary');
     if (varyHeader) {
       varyHeader = varyHeader.replace(/User-Agent/gi, '');
       varyHeader = varyHeader.replace(/Accept-Encoding/gi, '');
       varyHeader = varyHeader.replace(/[, ]*/g, '');
     }
-    return varyHeader && varyHeader.length && this.isCacheableResource(request) &&
-        this.freshnessLifetimeGreaterThan(request, 0);
+    return !!(
+        varyHeader && varyHeader.length && this.isCacheableResource(request) &&
+        this.freshnessLifetimeGreaterThan(request, 0));
   }
 
+  /**
+   * @param {!SDK.NetworkRequest} request
+   * @return {boolean}
+   */
   _oneMonthExpirationCheck(request) {
     return this.isCacheableResource(request) && !this.hasResponseHeader(request, 'Set-Cookie') &&
         !this.freshnessLifetimeGreaterThan(request, Audits.AuditRules.CacheControlRule.MillisPerMonth) &&
         this.freshnessLifetimeGreaterThan(request, 0);
   }
 
+  /**
+   * @param {!SDK.NetworkRequest} request
+   * @return {boolean}
+   */
   _oneYearExpirationCheck(request) {
     return this.isCacheableResource(request) && !this.hasResponseHeader(request, 'Set-Cookie') &&
         !this.freshnessLifetimeGreaterThan(request, 11 * Audits.AuditRules.CacheControlRule.MillisPerMonth) &&
         this.freshnessLifetimeGreaterThan(request, Audits.AuditRules.CacheControlRule.MillisPerMonth);
   }
 };
 
 /**
  * @unrestricted
  */
@@ skipping 11 matching lines @@
    * @param {!Common.Progress} progress
    */
   doRun(target, requests, result, callback, progress) {
     var domModel = SDK.DOMModel.fromTarget(target);
     var cssModel = SDK.CSSModel.fromTarget(target);
     if (!domModel || !cssModel) {
       callback(null);
       return;
     }
 
+    /** @type {!Object<string,number>} */

[luoe, 2017/01/13 08:05:22]

Nit: space after comma

[allada, 2017/01/17 19:16:25]

Done.

     var urlToNoDimensionCount = {};
 
     function doneCallback() {
       for (var url in urlToNoDimensionCount) {
         var entry = entry ||
             result.addChild(
                 Common.UIString(
                     'A width and height should be specified for all images in order to speed up page display. The following image(s) are missing a width and/or height:'),
                 true);
         var format = '%r';
         if (urlToNoDimensionCount[url] > 1)
           format += ' (%d uses)';
         entry.addFormatted(format, url, urlToNoDimensionCount[url]);
         result.violationCount++;
       }
       callback(entry ? result : null);
     }
 
+    /**
+     * @param {number} imageId
+     * @param {!{nodeStyles: (!Array<!SDK.CSSStyleDeclaration>|undefined), computedStyle: (?Map<string, string>|undefined)}} styles
+     */
     function imageStylesReady(imageId, styles) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
 
       const node = domModel.nodeForId(imageId);
       var src = node.getAttribute('src');
       if (!src.asParsedURL()) {
         for (var frameOwnerCandidate = node; frameOwnerCandidate;
@@ skipping 29 matching lines @@
     }
 
     /**
      * @param {!Array.<!Protocol.DOM.NodeId>=} nodeIds
      */
     function getStyles(nodeIds) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
+      /** @type {!{nodeStyles: (!Array<!SDK.CSSStyleDeclaration>|undefined), computedStyle: (?Map<string, string>|undefined)}} */
       var targetResult = {};
 
       /**
        * @param {?SDK.CSSMatchedStyles} matchedStyleResult
        */
       function matchedCallback(matchedStyleResult) {
         if (!matchedStyleResult)
           return;
         targetResult.nodeStyles = matchedStyleResult.nodeStyles();
       }
 
       /**
        * @param {?Map.<string, string>} computedStyle
        */
       function computedCallback(computedStyle) {
         targetResult.computedStyle = computedStyle;
       }
 
       if (!nodeIds || !nodeIds.length)
         doneCallback();
 
+      /** @type {!Array<!Promise>} */
       var nodePromises = [];
       for (var i = 0; nodeIds && i < nodeIds.length; ++i) {
+        /** @type {!Array<!Promise>} */
         var stylePromises = [
           cssModel.matchedStylesPromise(nodeIds[i]).then(matchedCallback),
           cssModel.computedStylePromise(nodeIds[i]).then(computedCallback)
         ];
         var nodePromise = Promise.all(stylePromises).then(imageStylesReady.bind(null, nodeIds[i], targetResult));
         nodePromises.push(nodePromise);
       }
       Promise.all(nodePromises).catchException(null).then(doneCallback);
     }
 
+    /**
+     * @param {!SDK.DOMDocument} root
+     */
     function onDocumentAvailable(root) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
       domModel.querySelectorAll(root.id, 'img[src]', getStyles);
     }
 
     if (progress.isCanceled()) {
       callback(null);
@@ skipping 19 matching lines @@
    * @param {function(?Audits.AuditRuleResult)} callback
    * @param {!Common.Progress} progress
    */
   doRun(target, requests, result, callback, progress) {
     var domModel = SDK.DOMModel.fromTarget(target);
     if (!domModel) {
       callback(null);
       return;
     }
 
+    /**
+     * @param {?Object<string, !Array<(number|!Array<string>)>>} evalResult
+     */
     function evalCallback(evalResult) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
 
       if (!evalResult)
         return callback(null);
 
       var summary = result.addChild('');
@@ skipping 20 matching lines @@
      */
     function externalStylesheetsReceived(root, inlineStyleNodeIds, nodeIds) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
 
       if (!nodeIds)
         return;
       var externalStylesheetNodeIds = nodeIds;
+      /** @type {?Object<string, !Array<(number|!Array<string>)>>} */
       var result = null;
       if (inlineStyleNodeIds.length || externalStylesheetNodeIds.length) {
+        /** @type {!Object<string, !Array<(number|!Array<string>)>>} */
         var urlToViolationsArray = {};
+        /** @type {!Array<string>} */
         var externalStylesheetHrefs = [];
         for (var j = 0; j < externalStylesheetNodeIds.length; ++j) {
           var linkNode = domModel.nodeForId(externalStylesheetNodeIds[j]);
           var completeHref =
               Common.ParsedURL.completeURL(linkNode.ownerDocument.baseURL, linkNode.getAttribute('href'));
           externalStylesheetHrefs.push(completeHref || '<empty>');
         }
         urlToViolationsArray[root.documentURL] = [inlineStyleNodeIds.length, externalStylesheetHrefs];
         result = urlToViolationsArray;
       }
@@ skipping 48 matching lines @@
    * @param {function(?Audits.AuditRuleResult)} callback
    * @param {!Common.Progress} progress
    */
   doRun(target, requests, result, callback, progress) {
     var domModel = SDK.DOMModel.fromTarget(target);
     if (!domModel) {
       callback(null);
       return;
     }
 
+    /**
+     * @param {?Array<!Array<string>|number>} resultValue
+     */
     function evalCallback(resultValue) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
 
       if (!resultValue)
         return callback(null);
 
       var lateCssUrls = resultValue[0];
       var cssBeforeInlineCount = resultValue[1];
 
       if (lateCssUrls.length) {
         var entry = result.addChild(
             Common.UIString(
                 'The following external CSS files were included after an external JavaScript file in the document head. To ensure CSS files are downloaded in parallel, always include external CSS before external JavaScript.'),
             true);
-        entry.addURLs(lateCssUrls);
+        entry.addURLs(/** @type {!Array<string>} */ (lateCssUrls));
         result.violationCount += lateCssUrls.length;
       }
 
       if (cssBeforeInlineCount) {
         result.addChild(Common.UIString(
             ' %d inline script block%s found in the head between an external CSS file and another resource. To allow parallel downloading, move the inline script before the external CSS file, or after the next resource.',
             cssBeforeInlineCount, cssBeforeInlineCount > 1 ? 's were' : ' was'));
         result.violationCount += cssBeforeInlineCount;
       }
       callback(result);
     }
 
     /**
      * @param {!Array.<!Protocol.DOM.NodeId>} lateStyleIds
      * @param {!Array.<!Protocol.DOM.NodeId>=} nodeIds
      */
     function cssBeforeInlineReceived(lateStyleIds, nodeIds) {
       if (progress.isCanceled()) {
         callback(null);
         return;
       }
 
       if (!nodeIds)
         return;
 
       var cssBeforeInlineCount = nodeIds.length;
+      /** @type {?Array<!Array<string>|number>} */
       var result = null;
       if (lateStyleIds.length || cssBeforeInlineCount) {
+        /** @type {!Array<string>} */
         var lateStyleUrls = [];
         for (var i = 0; i < lateStyleIds.length; ++i) {
           var lateStyleNode = domModel.nodeForId(lateStyleIds[i]);
           var completeHref =
               Common.ParsedURL.completeURL(lateStyleNode.ownerDocument.baseURL, lateStyleNode.getAttribute('href'));
           lateStyleUrls.push(completeHref || '<empty>');
         }
         result = [lateStyleUrls, cssBeforeInlineCount];
       }
 
@@ skipping 31 matching lines @@
           root.id, 'head script[src] ~ link[rel~=\'stylesheet\'][href]', lateStylesReceived.bind(null, root));
     }
 
     domModel.requestDocument(onDocumentAvailable);
   }
 };
 
 /**
  * @unrestricted
  */
 Audits.AuditRules.CSSRuleBase = class extends Audits.AuditRule {

[luoe, 2017/01/13 08:05:22]

Not related to typing, but it looks like this class is never used anywhere.  If
you decide to include Audits cleanup in this CL about cleaning up Audits, I'd
remove it now.

[allada, 2017/01/17 19:16:25]

I would rather not in this cl, I only want to protect our code from changes to
code elsewhere letting closure catch it. I don't want to change any of the
actual way things are done in this code since it's likely all getting removed.

+  /**
+   * @param {string} id
+   * @param {string} name
+   */
   constructor(id, name) {
     super(id, name);
   }
 
   /**
    * @override
    * @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) {
     var cssModel = SDK.CSSModel.fromTarget(target);
     if (!cssModel) {
       callback(null);
       return;
     }
 
     var headers = cssModel.allStyleSheets();
     if (!headers.length) {
       callback(null);
       return;
     }
+    /** @type {!Array<!SDK.CSSStyleSheetHeader>} */
     var activeHeaders = [];
     for (var i = 0; i < headers.length; ++i) {
       if (!headers[i].disabled)
         activeHeaders.push(headers[i]);
     }
 
     var styleSheetProcessor = new Audits.AuditRules.StyleSheetProcessor(
         activeHeaders, progress, this._styleSheetsLoaded.bind(this, result, callback, progress));
     styleSheetProcessor.run();
   }
@@ skipping 78 matching lines @@
    */
   visitProperty(styleSheet, rule, property, result) {
     // Subclasses can implement.
   }
 };
 
 /**
  * @unrestricted
  */
 Audits.AuditRules.CookieRuleBase = class extends Audits.AuditRule {
+  /**
+   * @param {string} id
+   * @param {string} name
+   */
   constructor(id, name) {
     super(id, name);
   }
 
   /**
    * @override
    * @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) {
     var self = this;
+    /**
+     * @param {!Array<!SDK.Cookie>} receivedCookies
+     */
     function resultCallback(receivedCookies) {
       if (progress.isCanceled()) {
         callback(result);
         return;
       }
 
       self.processCookies(receivedCookies, requests, result);
       callback(result);
     }
 
     SDK.Cookies.getCookiesAsync(resultCallback);
   }
 
+  /**
+   * @param {!Object<string, !Array<!SDK.NetworkRequest>>} requestsByDomain
+   * @param {!Array<!SDK.Cookie>} allCookies
+   * @param {function(!SDK.NetworkRequest, !SDK.Cookie)} callback
+   */
   mapResourceCookies(requestsByDomain, allCookies, callback) {
     for (var i = 0; i < allCookies.length; ++i) {
       for (var requestDomain in requestsByDomain) {
         if (SDK.Cookies.cookieDomainMatchesResourceDomain(allCookies[i].domain(), requestDomain))
           this._callbackForResourceCookiePairs(requestsByDomain[requestDomain], allCookies[i], callback);
       }
     }
   }
 
+  /**
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!SDK.Cookie} cookie
+   * @param {function(!SDK.NetworkRequest, !SDK.Cookie)} callback
+   */
   _callbackForResourceCookiePairs(requests, cookie, callback) {
     if (!requests)
       return;
     for (var i = 0; i < requests.length; ++i) {
-      if (SDK.Cookies.cookieMatchesResourceURL(cookie, requests[i].url))
+      if (SDK.Cookies.cookieMatchesResourceURL(cookie, requests[i].url()))
         callback(requests[i], cookie);
     }
   }
 };
 
 /**
  * @unrestricted
  */
 Audits.AuditRules.CookieSizeRule = class extends Audits.AuditRules.CookieRuleBase {
+  /**
+   * @param {number} avgBytesThreshold
+   */
   constructor(avgBytesThreshold) {
     super('http-cookiesize', Common.UIString('Minimize cookie size'));
     this._avgBytesThreshold = avgBytesThreshold;
     this._maxBytesThreshold = 1000;
   }
 
+  /**
+   * @param {!Array<!SDK.Cookie>} cookieArray

[luoe, 2017/01/13 08:05:22]

@return {number}

[allada, 2017/01/17 19:16:25]

Done.

+   */
   _average(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;
   }
 
+  /**
+   * @param {!Array<!SDK.Cookie>} cookieArray

[luoe, 2017/01/13 08:05:22]

ditto

[allada, 2017/01/17 19:16:25]

Done.

+   */
   _max(cookieArray) {
     var result = 0;
     for (var i = 0; i < cookieArray.length; ++i)
       result = Math.max(cookieArray[i].size(), result);
     return result;
   }
 
+  /**
+   * @param {!Array<!SDK.Cookie>} allCookies
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
+   */
   processCookies(allCookies, requests, result) {
+    /**
+     * @param {!{domain: string, avgCookieSize: number, maxCookieSize: number}} a

[luoe, 2017/01/13 08:05:23]

typedef CookieStats?
@return number

[allada, 2017/01/17 19:16:25]

Done.

+     * @param {!{domain: string, avgCookieSize: number, maxCookieSize: number}} b
+     */
     function maxSizeSorter(a, b) {
       return b.maxCookieSize - a.maxCookieSize;
     }
 
+    /**
+     * @param {!{domain: string, avgCookieSize: number, maxCookieSize: number}} a

[luoe, 2017/01/13 08:05:22]

ditto

+     * @param {!{domain: string, avgCookieSize: number, maxCookieSize: number}} b
+     */
     function avgSizeSorter(a, b) {
       return b.avgCookieSize - a.avgCookieSize;
     }
 
+    /** @type {!Object<string, !Array<!SDK.Cookie>>} */
     var cookiesPerResourceDomain = {};
 
+    /**
+     * @param {!SDK.NetworkRequest} request
+     * @param {!SDK.Cookie} cookie
+     */
     function collectorCallback(request, cookie) {
       var cookies = cookiesPerResourceDomain[request.parsedURL.host];
       if (!cookies) {
         cookies = [];

[luoe, 2017/01/13 08:05:22]

I guess closure doesn't complain about this?

[allada, 2017/01/17 19:16:25]

It can infer it from line 1500

[luoe, 2017/01/17 19:40:16]

I changed it to "cookies = [123]" and ran closure without any errors.  If you
decide to doctype new objects/arrays, let's add a doctype here too.

[allada, 2017/01/17 19:50:11]

What dgozman@ and I agreed on is that we should doctype things that are to be
passed into functions or used as arguments. Since "cookies" here is simply a
temp variable used to be assigned to an already typed item but never actually
used, I believe it would be overkill for what we are trying to protect against.

         cookiesPerResourceDomain[request.parsedURL.host] = cookies;
       }
       cookies.push(cookie);
     }
 
     if (!allCookies.length)
       return;
 
+    /** @type {!Array<!{domain: string, avgCookieSize: number, maxCookieSize: number}>} */
     var sortedCookieSizes = [];
 
-    var domainToResourcesMap = Audits.AuditRules.getDomainToResourcesMap(requests, null, true);
+    var domainToResourcesMap = Audits.AuditRules.getDomainToResourcesMap(requests, null);
     this.mapResourceCookies(domainToResourcesMap, allCookies, collectorCallback);
 
     for (var requestDomain in cookiesPerResourceDomain) {
       var cookies = cookiesPerResourceDomain[requestDomain];
       sortedCookieSizes.push(
           {domain: requestDomain, avgCookieSize: this._average(cookies), maxCookieSize: this._max(cookies)});
     }
     var avgAllCookiesSize = this._average(allCookies);
 
+    /** @type {!Array<string>} */
     var hugeCookieDomains = [];
     sortedCookieSizes.sort(maxSizeSorter);
 
     for (var i = 0, len = sortedCookieSizes.length; i < len; ++i) {
       var maxCookieSize = sortedCookieSizes[i].maxCookieSize;
       if (maxCookieSize > this._maxBytesThreshold) {
         hugeCookieDomains.push(
             Audits.AuditRuleResult.resourceDomain(sortedCookieSizes[i].domain) + ': ' +
             Number.bytesToString(maxCookieSize));
       }
     }
 
+    /** @type {!Array<string>} */
     var bigAvgCookieDomains = [];
     sortedCookieSizes.sort(avgSizeSorter);
     for (var i = 0, len = sortedCookieSizes.length; i < len; ++i) {
       var domain = sortedCookieSizes[i].domain;
       var avgCookieSize = sortedCookieSizes[i].avgCookieSize;
       if (avgCookieSize > this._avgBytesThreshold && avgCookieSize < this._maxBytesThreshold) {
         bigAvgCookieDomains.push(
             Audits.AuditRuleResult.resourceDomain(domain) + ': ' + Number.bytesToString(avgCookieSize));
       }
     }
@@ skipping 18 matching lines @@
       entry.addURLs(bigAvgCookieDomains);
       result.violationCount += bigAvgCookieDomains.length;
     }
   }
 };
 
 /**
  * @unrestricted
  */
 Audits.AuditRules.StaticCookielessRule = class extends Audits.AuditRules.CookieRuleBase {
+  /**
+   * @param {number} minResources
+   */
   constructor(minResources) {
     super('http-staticcookieless', Common.UIString('Serve static content from a cookieless domain'));
     this._minResources = minResources;
   }
 
+  /**
+   * @param {!Array<!SDK.Cookie>} allCookies
+   * @param {!Array<!SDK.NetworkRequest>} requests
+   * @param {!Audits.AuditRuleResult} result
+   */
   processCookies(allCookies, requests, result) {
     var domainToResourcesMap = Audits.AuditRules.getDomainToResourcesMap(
-        requests, [Common.resourceTypes.Stylesheet, Common.resourceTypes.Image], true);
+        requests, [Common.resourceTypes.Stylesheet, Common.resourceTypes.Image]);
     var totalStaticResources = 0;
     for (var domain in domainToResourcesMap)
       totalStaticResources += domainToResourcesMap[domain].length;
     if (totalStaticResources < this._minResources)
       return;
     /** @type {!Object<string, number>} */
     var matchingResourceData = {};
     this.mapResourceCookies(domainToResourcesMap, allCookies, this._collectorCallback.bind(this, matchingResourceData));
 
+    /** @type {!Array<string>} */
     var badUrls = [];
     var cookieBytes = 0;
     for (var url in matchingResourceData) {
       badUrls.push(url);
       cookieBytes += matchingResourceData[url];
     }
     if (badUrls.length < this._minResources)
       return;
 
     var entry = result.addChild(
         Common.UIString(
             '%s of cookies were sent with the following static resources. Serve these static resources from a domain that does not set cookies:',
             Number.bytesToString(cookieBytes)),
         true);
     entry.addURLs(badUrls);
     result.violationCount = badUrls.length;
   }
 
   /**
    * @param {!Object<string, number>} matchingResourceData
    * @param {!SDK.NetworkRequest} request
    * @param {!SDK.Cookie} cookie
    */
   _collectorCallback(matchingResourceData, request, cookie) {
     matchingResourceData[request.url()] = (matchingResourceData[request.url()] || 0) + cookie.size();
   }
 };