Coverage: convert coverage ranges to disjoint segments before further processing

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 {{end: number, count: (number|undefined), depth: number}} */

[alph, 2017/03/10 02:05:09]

Wouldn't it be more convenient to have a start instead?

+Coverage.CoverageSegment;
+
 /** @typedef {{
  *    contentProvider: !Common.ContentProvider,
  *    size: number,
  *    unusedSize: number,
  *    usedSize: number,
  *    type: !Coverage.CoverageType,
  *    lineOffset: number,
  *    columnOffset: number,
- *    ranges: !Array<!Coverage.RangeUseCount>
+ *    segments: !Array<!Coverage.CoverageSegment>
  * }}
  */
 Coverage.CoverageInfo;
 
 /**
  * @enum {number}
  */
 Coverage.CoverageType = {
   CSS: (1 << 0),
   JavaScript: (1 << 1),
@@ skipping 75 matching lines @@
    * @return {!Array<!Coverage.CoverageInfo>}
    */
   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)

[alph, 2017/03/10 02:05:08]

slice it?

-          ranges.push({startOffset: range.startOffset, endOffset: range.endOffset, count: range.count});
+          ranges.push(range);
       }
+      ranges.sort((a, b) => a.startOffset - b.startOffset);
       result.push(Coverage.CoverageModel._buildCoverageInfo(
           script, script.contentLength, script.lineOffset, script.columnOffset, ranges));
     }
     return result;
   }
 
   /**
+   * @param {!Array<!Coverage.RangeUseCount>} ranges
+   * @return {!Array<!Coverage.CoverageSegment>}
+   */
+  static _convertToDisjointSegments(ranges) {
+    var result = [];
+
+    var stack = [];
+    for (var entry of ranges) {
+      var top = stack.peekLast();
+      while (top && top.endOffset <= entry.startOffset) {
+        append(top.endOffset, top.count, stack.length);
+        stack.pop();
+        top = stack.peekLast();
+      }
+      append(entry.startOffset, top ? top.count : undefined, stack.length);
+      stack.push(entry);
+    }
+
+    while (stack.length) {
+      var depth = stack.length;
+      var top = stack.pop();
+      append(top.endOffset, top.count, depth);
+    }
+
+    function append(end, count, depth) {

[alph, 2017/03/10 02:05:08]

annotate plz

+      var last = result.peekLast();
+      if (last) {
+        if (last.end === end)
+          return;
+        if (last.count === count && last.depth === depth) {
+          last.end = end;
+          return;
+        }
+      }
+      result.push({end: end, count: count, depth: depth});
+    }
+
+    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);
   }
@@ skipping 33 matching lines @@
     /** @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 = [];
-    ranges.sort((a, b) => a.startOffset - b.startOffset);
-    for (var entry of ranges) {
-      while (stack.length && stack.peekLast().endOffset <= entry.startOffset)
-        stack.pop();
-
-      entry.ownSize = entry.endOffset - entry.startOffset;
-      var top = stack.peekLast();
-      if (top) {
-        if (top.endOffset < entry.endOffset) {
-          console.assert(
-              false, `Overlapping coverage entries in ${url}: ${top.start}-${top.end} vs. ${entry.start}-${entry.end}`);
-        }
-        top.ownSize -= entry.ownSize;
-      }
-      stack.push(entry);
-    }
-
+    var segments = Coverage.CoverageModel._convertToDisjointSegments(ranges);
     var usedSize = 0;
     var unusedSize = 0;
-    for (var entry of ranges) {
-      if (entry.count)
-        usedSize += entry.ownSize;
-      else
-        unusedSize += entry.ownSize;
+    var last = 0;
+    for (var segment of segments) {
+      if (typeof segment.count === 'number') {
+        if (segment.count)
+          usedSize += segment.end - last;
+        else
+          unusedSize += segment.end - last;
+      }
+      last = segment.end;
     }
-
     var coverageInfo = {
       contentProvider: contentProvider,
-      ranges: ranges,
+      segments: segments,
       type: coverageType,
       size: contentLength,
       usedSize: usedSize,
       unusedSize: unusedSize,
       lineOffset: startLine,
       columnOffset: startColumn
     };
     return coverageInfo;
   }
 };