DevTools: support live 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)}} */
 Coverage.CoverageSegment;
 
@@ skipping 10 matching lines @@
    * @param {!SDK.Target} target
    */
   constructor(target) {
     super(target);
     this._cpuProfilerModel = target.model(SDK.CPUProfilerModel);
     this._cssModel = target.model(SDK.CSSModel);
     this._debuggerModel = target.model(SDK.DebuggerModel);
 
     /** @type {!Map<string, !Coverage.URLCoverageInfo>} */
     this._coverageByURL = new Map();
+    /** @type {!Map<!Common.ContentProvider, !Coverage.CoverageInfo>} */
+    this._coverageByContentProvider = new Map();
   }
 
   /**
    * @return {boolean}
    */
   start() {
     this._coverageByURL.clear();
     if (this._cssModel)
-      this._cssModel.startRuleUsageTracking();
+      this._cssModel.startCoverage();
     if (this._cpuProfilerModel)
       this._cpuProfilerModel.startPreciseCoverage();
     return !!(this._cssModel || this._cpuProfilerModel);
   }
 
   /**
-   * @return {!Promise<!Array<!Coverage.URLCoverageInfo>>}
+   * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
    */
-  async stop() {
-    await Promise.all([this._stopCSSCoverage(), this._stopJSCoverage()]);
+  stop() {
+    var pollPromise = this.poll();
+    if (this._cpuProfilerModel)
+      this._cpuProfilerModel.stopPreciseCoverage();
+    if (this._cssModel)
+      this._cssModel.stopCoverage();
+    return pollPromise;
+  }
+
+  /**
+   * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
+   */
+  async poll() {
+    var updates = await Promise.all([this._takeCSSCoverage(), this._takeJSCoverage()]);
+    return updates[0].concat(updates[1]);
+  }
+
+  /**
+   * @return {!Array<!Coverage.URLCoverageInfo>}
+   */
+  entries() {
     return Array.from(this._coverageByURL.values());
   }
 
-  async _stopJSCoverage() {
+  /**
+   * @param {!Common.ContentProvider} contentProvider
+   * @param {number} startOffset
+   * @param {number} endOffset
+   * @return {boolean|undefined}
+   */
+  usageForRange(contentProvider, startOffset, endOffset) {
+    var coverageInfo = this._coverageByContentProvider.get(contentProvider);
+    return coverageInfo && coverageInfo.usageForRange(startOffset, endOffset);
+  }
+
+  /**
+   * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
+   */
+  async _takeJSCoverage() {
     if (!this._cpuProfilerModel)
-      return;
-    var coveragePromise = this._cpuProfilerModel.takePreciseCoverage();
-    this._cpuProfilerModel.stopPreciseCoverage();
-    var rawCoverageData = await coveragePromise;
-    this._processJSCoverage(rawCoverageData);
+      return [];
+    var rawCoverageData = await this._cpuProfilerModel.takePreciseCoverage();
+    return this._processJSCoverage(rawCoverageData);
   }
 
   /**
    * @param {!Array<!Protocol.Profiler.ScriptCoverage>} scriptsCoverage
+   * @return {!Array<!Coverage.CoverageInfo>}
    */
   _processJSCoverage(scriptsCoverage) {
+    var updatedEntries = [];
     for (var entry of scriptsCoverage) {
       var script = this._debuggerModel.scriptForId(entry.scriptId);
       if (!script)
         continue;
       var ranges = [];
       for (var func of entry.functions) {
         for (var range of func.ranges)
           ranges.push(range);
       }
-      this._addCoverage(script, script.contentLength, script.lineOffset, script.columnOffset, ranges);
+      var entry = this._addCoverage(script, script.contentLength, script.lineOffset, script.columnOffset, ranges);
+      if (entry)
+        updatedEntries.push(entry);
     }
+    return updatedEntries;
   }
 
   /**
+   * @return {!Promise<!Array<!Coverage.CoverageInfo>>}
+   */
+  async _takeCSSCoverage() {
+    if (!this._cssModel)
+      return [];
+    var rawCoverageData = await this._cssModel.takeCoverageDelta();
+    return this._processCSSCoverage(rawCoverageData);
+  }
+
+  /**
+   * @param {!Array<!Protocol.CSS.RuleUsage>} ruleUsageList
+   * @return {!Array<!Coverage.CoverageInfo>}
+   */
+  _processCSSCoverage(ruleUsageList) {
+    var updatedEntries = [];
+    /** @type {!Map<!SDK.CSSStyleSheetHeader, !Array<!Coverage.RangeUseCount>>} */
+    var rulesByStyleSheet = new Map();
+    for (var rule of ruleUsageList) {
+      var styleSheetHeader = this._cssModel.styleSheetHeaderForId(rule.styleSheetId);
+      if (!styleSheetHeader)
+        continue;
+      var ranges = rulesByStyleSheet.get(styleSheetHeader);
+      if (!ranges) {
+        ranges = [];
+        rulesByStyleSheet.set(styleSheetHeader, ranges);
+      }
+      ranges.push({startOffset: rule.startOffset, endOffset: rule.endOffset, count: Number(rule.used)});
+    }
+    for (var entry of rulesByStyleSheet) {
+      var styleSheetHeader = /** @type {!SDK.CSSStyleSheetHeader} */ (entry[0]);
+      var ranges = /** @type {!Array<!Coverage.RangeUseCount>} */ (entry[1]);
+      var entry = this._addCoverage(
+          styleSheetHeader, styleSheetHeader.contentLength, styleSheetHeader.startLine, styleSheetHeader.startColumn,
+          ranges);
+      if (entry)
+        updatedEntries.push(entry);
+    }
+    return updatedEntries;
+  }
+
+  /**
    * @param {!Array<!Coverage.RangeUseCount>} ranges
    * @return {!Array<!Coverage.CoverageSegment>}
    */
   static _convertToDisjointSegments(ranges) {
     ranges.sort((a, b) => a.startOffset - b.startOffset);
 
     var result = [];
     var stack = [];
     for (var entry of ranges) {
       var top = stack.peekLast();
@@ skipping 24 matching lines @@
           last.end = end;
           return;
         }
       }
       result.push({end: end, count: count});
     }
 
     return result;
   }
 
-  async _stopCSSCoverage() {
-    if (!this._cssModel)
-      return [];
-
-    var rawCoverageData = await this._cssModel.ruleListPromise();
-    this._processCSSCoverage(rawCoverageData);
-  }
-
-  /**
-   * @param {!Array<!Protocol.CSS.RuleUsage>} ruleUsageList
-   */
-  _processCSSCoverage(ruleUsageList) {
-    /** @type {!Map<!SDK.CSSStyleSheetHeader, !Array<!Coverage.RangeUseCount>>} */
-    var rulesByStyleSheet = new Map();
-    for (var rule of ruleUsageList) {
-      var styleSheetHeader = this._cssModel.styleSheetHeaderForId(rule.styleSheetId);
-      if (!styleSheetHeader)
-        continue;
-      var ranges = rulesByStyleSheet.get(styleSheetHeader);
-      if (!ranges) {
-        ranges = [];
-        rulesByStyleSheet.set(styleSheetHeader, ranges);
-      }
-      ranges.push({startOffset: rule.startOffset, endOffset: rule.endOffset, count: Number(rule.used)});
-    }
-    for (var entry of rulesByStyleSheet) {
-      var styleSheetHeader = /** @type {!SDK.CSSStyleSheetHeader} */ (entry[0]);
-      var ranges = /** @type {!Array<!Coverage.RangeUseCount>} */ (entry[1]);
-      this._addCoverage(
-          styleSheetHeader, styleSheetHeader.contentLength, styleSheetHeader.startLine, styleSheetHeader.startColumn,
-          ranges);
-    }
-  }
-
   /**
    * @param {!Common.ContentProvider} contentProvider
    * @param {number} contentLength
    * @param {number} startLine
    * @param {number} startColumn
    * @param {!Array<!Coverage.RangeUseCount>} ranges
+   * @return {?Coverage.CoverageInfo}
    */
   _addCoverage(contentProvider, contentLength, startLine, startColumn, ranges) {
     var url = contentProvider.contentURL();
     if (!url)
-      return;
-    var entry = this._coverageByURL.get(url);
-    if (!entry) {
-      entry = new Coverage.URLCoverageInfo(url);
-      this._coverageByURL.set(url, entry);
+      return null;
+    var urlCoverage = this._coverageByURL.get(url);
+    if (!urlCoverage) {
+      urlCoverage = new Coverage.URLCoverageInfo(url);
+      this._coverageByURL.set(url, urlCoverage);
     }
+    var coverageInfo = urlCoverage._ensureEntry(contentProvider, contentLength, startLine, startColumn);
+    this._coverageByContentProvider.set(contentProvider, coverageInfo);
     var segments = Coverage.CoverageModel._convertToDisjointSegments(ranges);
     if (segments.length && segments.peekLast().end < contentLength)
       segments.push({end: contentLength});
-    entry.update(contentProvider, contentLength, startLine, startColumn, segments);
+    var oldUsedSize = coverageInfo._usedSize;
+    coverageInfo.mergeCoverage(segments);
+    if (coverageInfo._usedSize === oldUsedSize)
+      return null;
+    urlCoverage._usedSize += coverageInfo._usedSize - oldUsedSize;
+    return coverageInfo;
   }
 };
 
 Coverage.URLCoverageInfo = class {
   /**
    * @param {string} url
    */
   constructor(url) {
     this._url = url;
     /** @type {!Map<string, !Coverage.CoverageInfo>} */
     this._coverageInfoByLocation = new Map();
     this._size = 0;
     this._usedSize = 0;
     /** @type {!Coverage.CoverageType} */
     this._type;
   }
 
   /**
-   * @param {!Common.ContentProvider} contentProvider
-   * @param {number} contentLength
-   * @param {number} lineOffset
-   * @param {number} columnOffset
-   * @param {!Array<!Coverage.CoverageSegment>} segments
-   */
-  update(contentProvider, contentLength, lineOffset, columnOffset, segments) {
-    var key = `${lineOffset}:${columnOffset}`;
-    var entry = this._coverageInfoByLocation.get(key);
-
-    if (!entry) {
-      entry = new Coverage.CoverageInfo(contentProvider, lineOffset, columnOffset);
-      this._coverageInfoByLocation.set(key, entry);
-      this._size += contentLength;
-      this._type |= entry.type();
-    }
-    this._usedSize -= entry._usedSize;
-    entry.mergeCoverage(segments);
-    this._usedSize += entry._usedSize;
-  }
-
-  /**
    * @return {string}
    */
   url() {
     return this._url;
   }
 
   /**
    * @return {!Coverage.CoverageType}
    */
   type() {
@@ skipping 15 matching lines @@
   }
 
   /**
    * @return {number}
    */
   unusedSize() {
     return this._size - this._usedSize;
   }
 
   /**
-   * @return {!Promise<!Array<!{range: !TextUtils.TextRange, count: number}>>}
+   * @param {!Common.ContentProvider} contentProvider
+   * @param {number} contentLength
+   * @param {number} lineOffset
+   * @param {number} columnOffset
+   * @return {!Coverage.CoverageInfo}
    */
-  async buildTextRanges() {
-    var textRangePromises = [];
-    for (var coverageInfo of this._coverageInfoByLocation.values())
-      textRangePromises.push(coverageInfo.buildTextRanges());
-    var allTextRanges = await Promise.all(textRangePromises);
-    return [].concat(...allTextRanges);
+  _ensureEntry(contentProvider, contentLength, lineOffset, columnOffset) {
+    var key = `${lineOffset}:${columnOffset}`;
+    var entry = this._coverageInfoByLocation.get(key);
+
+    if (!entry) {
+      entry = new Coverage.CoverageInfo(contentProvider, lineOffset, columnOffset);
+      this._coverageInfoByLocation.set(key, entry);
+      this._size += contentLength;
+      this._type |= entry.type();
+    }
+    return entry;
   }
 };
 
 Coverage.CoverageInfo = class {
   /**
    * @param {!Common.ContentProvider} contentProvider
    * @param {number} lineOffset
    * @param {number} columnOffset
    */
   constructor(contentProvider, lineOffset, columnOffset) {
     this._contentProvider = contentProvider;
     this._lineOffset = lineOffset;
     this._columnOffset = columnOffset;
     this._usedSize = 0;
 
     if (contentProvider.contentType().isScript()) {
       this._coverageType = Coverage.CoverageType.JavaScript;
     } else if (contentProvider.contentType().isStyleSheet()) {
       this._coverageType = Coverage.CoverageType.CSS;
     } else {
       console.assert(
           false, `Unexpected resource type ${contentProvider.contentType().name} for ${contentProvider.contentURL()}`);
     }
     /** !Array<!Coverage.CoverageSegment> */
     this._segments = [];
   }
 
   /**
+   * @return {!Common.ContentProvider}
+   */
+  contentProvider() {
+    return this._contentProvider;
+  }
+
+  /**
+   * @return {string}
+   */
+  url() {
+    return this._contentProvider.contentURL();
+  }
+
+  /**
    * @return {!Coverage.CoverageType}
    */
   type() {
     return this._coverageType;
   }
 
   /**
    * @param {!Array<!Coverage.CoverageSegment>} segments
    */
   mergeCoverage(segments) {
     this._segments = Coverage.CoverageInfo._mergeCoverage(this._segments, segments);
     this._updateStats();
   }
 
   /**
+   * @param {number} start
+   * @param {number} end
+   * @return {boolean}
+   */
+  usageForRange(start, end) {
+    var index = this._segments.upperBound(start, (position, segment) => position - segment.end);
+    for (; index < this._segments.length && this._segments[index].end < end; ++index) {
+      if (this._segments[index].count)
+        return true;
+    }
+    return index < this._segments.length && this._segments[index].count;

[alph, 2017/05/05 22:50:36]

I'll repeat my question: can't this segment be beyond the end boundary? If so,
why do you take it into account?

+  }
+
+  /**
    * @param {!Array<!Coverage.CoverageSegment>} segmentsA
    * @param {!Array<!Coverage.CoverageSegment>} segmentsB
    */
   static _mergeCoverage(segmentsA, segmentsB) {
     var result = [];
 
     var indexA = 0;
     var indexB = 0;
     while (indexA < segmentsA.length && indexB < segmentsB.length) {
       var a = segmentsA[indexA];
@@ skipping 12 matching lines @@
         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: !TextUtils.TextRange, count: number}>>}
-   */
-  async buildTextRanges() {
-    var contents = await this._contentProvider.requestContent();
-    if (!contents)
-      return [];
-    var text = new TextUtils.Text(contents);
-    var lastOffset = 0;
-    var result = [];
-    for (var segment of this._segments) {
-      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 range = new TextUtils.TextRange(
-          startPosition.lineNumber, startPosition.columnNumber, endPosition.lineNumber, endPosition.columnNumber);
-      result.push({count: segment.count || 0, range: range});
-      lastOffset = segment.end;
-    }
-    return result;
-  }
-
   _updateStats() {
     this._usedSize = 0;
 
     var last = 0;
     for (var segment of this._segments) {
       if (segment.count)
         this._usedSize += segment.end - last;
       last = segment.end;
     }
   }
 };