DevTools: remove nesting depth tracking from coverage

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}} */
+/** @typedef {{end: number, count: (number|undefined)}} */
 Coverage.CoverageSegment;
 
 /**
  * @enum {number}
  */
 Coverage.CoverageType = {
   CSS: (1 << 0),
   JavaScript: (1 << 1),
 };
 
@@ skipping 62 matching lines @@
    * @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);
+        append(top.endOffset, top.count);
         stack.pop();
         top = stack.peekLast();
       }
-      append(entry.startOffset, top ? top.count : undefined, stack.length);
+      append(entry.startOffset, top ? top.count : undefined);
       stack.push(entry);
     }
 
     while (stack.length) {
-      var depth = stack.length;
       var top = stack.pop();
-      append(top.endOffset, top.count, depth);
+      append(top.endOffset, top.count);
     }
 
     /**
      * @param {number} end
      * @param {number} count
-     * @param {number} depth
      */
-    function append(end, count, depth) {
+    function append(end, count) {
       var last = result.peekLast();
       if (last) {
         if (last.end === end)
           return;
-        if (last.count === count && last.depth === depth) {
+        if (last.count === count) {
           last.end = end;
           return;
         }
       }
-      result.push({end: end, count: count, depth: depth});
+      result.push({end: end, count: count});
     }
 
     return result;
   }
 
   async _stopCSSCoverage() {
     if (!this._cssModel)
       return [];
 
     var rawCoverageData = await this._cssModel.ruleListPromise();
@@ skipping 180 matching lines @@
   static _mergeCoverage(segmentsA, segmentsB) {
     var result = [];
 
     var indexA = 0;
     var indexB = 0;
     while (indexA < segmentsA.length && indexB < segmentsB.length) {
       var a = segmentsA[indexA];
       var b = segmentsB[indexB];
       var count =
           typeof a.count === 'number' || typeof b.count === 'number' ? (a.count || 0) + (b.count || 0) : undefined;
-      var depth = Math.max(a.depth, b.depth);
       var end = Math.min(a.end, b.end);
       var last = result.peekLast();
-      if (!last || last.count !== count || last.depth !== depth)
-        result.push({end: end, count: count, depth: depth});
+      if (!last || last.count !== count)
+        result.push({end: end, count: count});
       else
         last.end = end;
       if (a.end <= b.end)
         indexA++;
       if (a.end >= b.end)
         indexB++;
     }
 
     for (; indexA < segmentsA.length; indexA++)
       result.push(segmentsA[indexA]);
     for (; indexB < segmentsB.length; indexB++)
       result.push(segmentsB[indexB]);
     return result;
   }
 
   /**
    * @return {!Promise<!Array<!{range: !Common.TextRange, count: number}>>}
    */
   async buildTextRanges() {
     var contents = await this._contentProvider.requestContent();
     if (!contents)
       return [];
     var text = new Common.Text(contents);
     var lastOffset = 0;
-    var rangesByDepth = [];
+    var result = [];
     for (var segment of this._segments) {
-      if (typeof segment.count !== 'number') {
-        lastOffset = segment.end;
+      if (!segment.end)
         continue;
-      }
       var startPosition = text.positionFromOffset(lastOffset);
       var endPosition = text.positionFromOffset(segment.end);
       if (!startPosition.lineNumber)
         startPosition.columnNumber += this._columnOffset;
       startPosition.lineNumber += this._lineOffset;
       if (!endPosition.lineNumber)
         endPosition.columnNumber += this._columnOffset;
       endPosition.lineNumber += this._lineOffset;
-
-      var ranges = rangesByDepth[segment.depth - 1];  // depth === 0 => count === undefined
-      if (!ranges) {
-        ranges = [];
-        rangesByDepth[segment.depth - 1] = ranges;
-      }
-      ranges.push({
-        count: segment.count,
-        range: new Common.TextRange(
-            startPosition.lineNumber, startPosition.columnNumber, endPosition.lineNumber, endPosition.columnNumber)
-      });
+      var range = new Common.TextRange(
+          startPosition.lineNumber, startPosition.columnNumber, endPosition.lineNumber, endPosition.columnNumber);
+      result.push({count: segment.count || 0, range: range});
       lastOffset = segment.end;
     }
-    var result = [];
-    for (var ranges of rangesByDepth) {
-      for (var r of ranges)
-        result.push({count: r.count, range: r.range});
-    }
     return result;
   }
 
   _updateStats() {
     this._usedSize = 0;
     this._unusedSize = 0;
 
     var last = 0;
     for (var segment of this._segments) {
       if (typeof segment.count === 'number') {
         if (segment.count)
           this._usedSize += segment.end - last;
         else
           this._unusedSize += segment.end - last;
       }
       last = segment.end;
     }
   }
 };