DevTools: add CSS/JS type indication to coverage view

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

 // Copyright (c) 2016 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 {{range: !Common.TextRange, wasUsed: boolean}} */
 Coverage.RangeUsage;
 
 /** @typedef {{styleSheetHeader: !SDK.CSSStyleSheetHeader, ranges: !Array<!Coverage.RangeUsage>}} */
 Coverage.StyleSheetUsage;
 
-/** @typedef {{url: string, size: (number|undefined), unusedSize: (number|undefined), usedSize: (number|undefined),
- *      ranges: !Array<!Coverage.RangeUsage>}} */
+/** @typedef {{
+ *    url: string,
+ *    size: (number|undefined),
+ *    unusedSize: (number|undefined),
+ *    usedSize: (number|undefined),
+ *    type: !Coverage.CoverageType,
+ *    ranges: !Array<!Coverage.RangeUsage>
+ * }}
+ */
 Coverage.CoverageInfo;
 
+/**
+ * @enum {number}
+ */
+Coverage.CoverageType = {
+  CSS: (1 << 0),
+  JavaScript: (1 << 1),
+};
+
 Coverage.CoverageView = class extends UI.VBox {
   constructor() {
     super(true);
 
     this.registerRequiredCSS('coverage/coverageView.css');
 
     var toolbarContainer = this.contentElement.createChild('div', 'coverage-toolbar-container');
     var topToolbar = new UI.Toolbar('coverage-toolbar', toolbarContainer);
 
     this._toggleRecordAction =
@@ skipping 80 matching lines @@
     coverageInfo.sort((a, b) => (a.url || '').localeCompare(b.url));
     var result = [];
     for (var entry of coverageInfo) {
       if (!entry.url)
         continue;
       if (result.length && result.peekLast().url === entry.url) {
         var lastEntry = result.peekLast();
         lastEntry.size += entry.size;
         lastEntry.usedSize += entry.usedSize;
         lastEntry.unusedSize += entry.unusedSize;
+        lastEntry.type |= entry.type;
       } else {
         result.push(entry);
       }
     }
     return result;
   }
 
   /**
    * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
    */
@@ skipping 21 matching lines @@
       var script = debuggerModel.scriptForId(entry.scriptId);
       if (!script)
         continue;
       for (var func of entry.functions) {
         for (var range of func.ranges) {
           var textRange = new Common.TextRange(
               range.startLineNumber, range.startColumnNumber, range.endLineNumber, range.endColumnNumber);
           ranges.push({range: textRange, wasUsed: !!range.count});
         }
       }
-      promises.push(convertToCoverageInfo(script, ranges));
+      promises.push(Coverage.CoverageView._coverageInfoForText(script, script.lineOffset, script.columnOffset, ranges));
     }
     return Promise.all(promises);
-
-    /**
-     * @param {!SDK.Script} script
-     * @param {!Array<!Coverage.RangeUsage>} ranges
-     * @return {!Promise<!Coverage.CoverageInfo>}
-     */
-    function convertToCoverageInfo(script, ranges) {
-      return script.requestContent().then(
-          content => Coverage.CoverageView._coverageInfoForText(
-              script.contentURL(), script.lineOffset, script.columnOffset, content, ranges));
-    }
   }
 
   /**
    * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
    */
   async _stopCSSCoverage() {
     var mainTarget = SDK.targetManager.mainTarget();
     const cssModel = mainTarget && mainTarget.model(SDK.CSSModel);
     if (!cssModel)
       return Promise.resolve([]);
@@ skipping 18 matching lines @@
         ranges = [];
         rulesByStyleSheet.set(styleSheetHeader, ranges);
       }
       var textRange = new Common.TextRange(
           rule.range.startLine + styleSheetHeader.startLine,
           rule.range.startColumn + (rule.range.startLine ? 0 : styleSheetHeader.startColumn),
           rule.range.endLine + styleSheetHeader.startLine,
           rule.range.endColumn + (rule.range.endLine ? 0 : styleSheetHeader.startColumn));
       ranges.push({range: textRange, wasUsed: rule.wasUsed});
     }
-    return Promise.all(Array.from(rulesByStyleSheet.entries(), entry => convertToCoverageInfo(entry[0], entry[1])));
-
-    /**
-     * @param {!SDK.CSSStyleSheetHeader} styleSheetHeader
-     * @param {!Array<!Coverage.RangeUsage>} ranges
-     * @return {!Promise<!Coverage.CoverageInfo>}
-     */
-    function convertToCoverageInfo(styleSheetHeader, ranges) {
-      return styleSheetHeader.requestContent().then(
-          content => Coverage.CoverageView._coverageInfoForText(
-              styleSheetHeader.sourceURL, styleSheetHeader.startLine, styleSheetHeader.startColumn, content, ranges));
-    }
+    return Promise.all(Array.from(
+        rulesByStyleSheet.entries(), entry => Coverage.CoverageView._coverageInfoForText(

[alph, 2017/02/28 01:10:38]

nit: ([header, ranges]) => Coverage.CoverageView._coverageInfoForText(...

+                                         entry[0], entry[0].startLine, entry[0].startColumn, entry[1])));
   }
 
   /**
-   * @param {string} url
+   * @param {!Common.ContentProvider} contentProvider
    * @param {number} startLine
    * @param {number} startColumn
-   * @param {?string} content
    * @param {!Array<!Coverage.RangeUsage>} ranges
-   * @return {!Coverage.CoverageInfo}
+   * @return {!Promise<!Coverage.CoverageInfo>}
    */
-  static _coverageInfoForText(url, startLine, startColumn, content, ranges) {
-    var coverageInfo = {
-      url: url,
-      ranges: ranges,
-    };
+  static async _coverageInfoForText(contentProvider, startLine, startColumn, ranges) {
+    var url = contentProvider.contentURL();
+    var coverageType;
+    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 coverageInfo = {url: url, ranges: ranges, type: coverageType};
+    var content = await contentProvider.requestContent();
     if (!content)
       return coverageInfo;
 
     var text = new Common.Text(content);
     var offsetRanges = ranges.map(r => {
       var range = r.range.relativeTo(startLine, startColumn);
       return {
         start: text.offsetFromPosition(range.startLine, range.startColumn),
         end: text.offsetFromPosition(range.endLine, range.endColumn),
         wasUsed: r.wasUsed
@@ skipping 111 matching lines @@
    */
   handleAction(context, actionId) {
     var coverageViewId = 'coverage';
     UI.viewManager.showView(coverageViewId)
         .then(() => UI.viewManager.view(coverageViewId).widget())
         .then(widget => /** @type !Coverage.CoverageView} */ (widget)._toggleRecording());
 
     return true;
   }
 };