DevTools coverage: get script/stylesheet size directly, do not request content

third_party/WebKit/Source/devtools/front_end/coverage/CoverageModel.js

 // Copyright (c) 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** @typedef {{startOffset: number, endOffset: number, count: number}} */
 Coverage.RangeUseCount;
 
 /** @typedef {{
  *    contentProvider: !Common.ContentProvider,
- *    size: (number|undefined),
- *    unusedSize: (number|undefined),
- *    usedSize: (number|undefined),
+ *    size: number,
+ *    unusedSize: number,
+ *    usedSize: number,
  *    type: !Coverage.CoverageType,
  *    lineOffset: number,
  *    columnOffset: number,
  *    ranges: !Array<!Coverage.RangeUseCount>
  * }}
  */
 Coverage.CoverageInfo;
 
 /**
  * @enum {number}
@@ skipping 69 matching lines @@
     var coveragePromise = this._cpuProfilerModel.takePreciseCoverage();
     this._cpuProfilerModel.stopPreciseCoverage();
     var rawCoverageData = await coveragePromise;
     return Coverage.CoverageModel._processJSCoverage(
         /** @type !SDK.DebuggerModel */ (SDK.DebuggerModel.fromTarget(this.target())), rawCoverageData);
   }
 
   /**
    * @param {!SDK.DebuggerModel} debuggerModel
    * @param {!Array<!Protocol.Profiler.ScriptCoverage>} scriptsCoverage
-   * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
+   * @return {!Array<!Coverage.CoverageInfo>}
    */
-  static async _processJSCoverage(debuggerModel, scriptsCoverage) {
-    var promises = [];
+  static _processJSCoverage(debuggerModel, scriptsCoverage) {
+    var result = [];
     for (var entry of scriptsCoverage) {
       var script = debuggerModel.scriptForId(entry.scriptId);
       if (!script)
         continue;
       var ranges = [];
       for (var func of entry.functions) {
         for (var range of func.ranges)
           ranges.push({startOffset: range.startOffset, endOffset: range.endOffset, count: range.count});
       }
-      promises.push(
-          Coverage.CoverageModel._coverageInfoForText(script, script.lineOffset, script.columnOffset, ranges));
+      result.push(Coverage.CoverageModel._buildCoverageInfo(
+          script, script.contentLength, script.lineOffset, script.columnOffset, ranges));
     }
-    return Promise.all(promises);
+    return result;
   }
 
   /**
    * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
    */
   async _stopCSSCoverage() {
     if (!this._cssModel)
       return [];
 
     var rawCoverageData = await this._cssModel.ruleListPromise();
     return Coverage.CoverageModel._processCSSCoverage(
         /** @type !SDK.CSSModel */ (this._cssModel), rawCoverageData);
   }
 
   /**
    * @param {!SDK.CSSModel} cssModel
    * @param {!Array<!Protocol.CSS.RuleUsage>} ruleUsageList
-   * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
+   * @return {!Array<!Coverage.CoverageInfo>}
    */
-  static async _processCSSCoverage(cssModel, ruleUsageList) {
+  static _processCSSCoverage(cssModel, ruleUsageList) {
     /** @type {!Map<?SDK.CSSStyleSheetHeader, !Array<!Coverage.RangeUseCount>>} */
     var rulesByStyleSheet = new Map();
     for (var rule of ruleUsageList) {
       var styleSheetHeader = cssModel.styleSheetHeaderForId(rule.styleSheetId);
       var ranges = rulesByStyleSheet.get(styleSheetHeader);
       if (!ranges) {
         ranges = [];
         rulesByStyleSheet.set(styleSheetHeader, ranges);
       }
       ranges.push({startOffset: rule.startOffset, endOffset: rule.endOffset, count: Number(rule.used)});
     }
-    return Promise.all(Array.from(
+    return Array.from(
         rulesByStyleSheet.entries(),
-        entry =>
-            Coverage.CoverageModel._coverageInfoForText(entry[0], entry[0].startLine, entry[0].startColumn, entry[1])));
+        entry => Coverage.CoverageModel._buildCoverageInfo(
+            entry[0], entry[0].contentLength, entry[0].startLine, entry[0].startColumn, entry[1]));
   }
 
   /**
    * @param {!Common.ContentProvider} contentProvider
+   * @param {number} contentLength
    * @param {number} startLine
    * @param {number} startColumn
    * @param {!Array<!Coverage.RangeUseCount>} ranges
-   * @return {!Promise<?Coverage.CoverageInfo>}
+   * @return {!Coverage.CoverageInfo}
    */
-  static async _coverageInfoForText(contentProvider, startLine, startColumn, ranges) {
+  static _buildCoverageInfo(contentProvider, contentLength, startLine, startColumn, ranges) {
+    /** @type Coverage.CoverageType */
     var coverageType;
     var url = contentProvider.contentURL();
     if (contentProvider.contentType().isScript())
       coverageType = Coverage.CoverageType.JavaScript;
     else if (contentProvider.contentType().isStyleSheet())
       coverageType = Coverage.CoverageType.CSS;
     else
       console.assert(false, `Unexpected resource type ${contentProvider.contentType().name} for ${url}`);
 
     var stack = [];
@@ skipping 16 matching lines @@
 
     var usedSize = 0;
     var unusedSize = 0;
     for (var entry of ranges) {
       if (entry.count)
         usedSize += entry.ownSize;
       else
         unusedSize += entry.ownSize;
     }
 
-    // FIXME: get rid of this when we get the size upfront.
-    var content = await contentProvider.requestContent();
-    if (typeof content !== 'string')
-      return null;
-
     var coverageInfo = {
       contentProvider: contentProvider,
       ranges: ranges,
       type: coverageType,
-      size: content.length,
+      size: contentLength,
       usedSize: usedSize,
       unusedSize: unusedSize,
       lineOffset: startLine,
       columnOffset: startColumn
     };
     return coverageInfo;
   }
 };