| // 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; |
| |
| /** |
| * @enum {number} |
| */ |
| Coverage.CoverageType = { |
| CSS: (1 << 0), |
| JavaScript: (1 << 1), |
| }; |
| |
| Coverage.CoverageModel = class extends SDK.SDKModel { |
| /** |
| * @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(); |
| } |
| |
| /** |
| * @return {boolean} |
| */ |
| start() { |
| this._coverageByURL.clear(); |
| if (this._cssModel) |
| this._cssModel.startRuleUsageTracking(); |
| if (this._cpuProfilerModel) |
| this._cpuProfilerModel.startPreciseCoverage(); |
| return !!(this._cssModel || this._cpuProfilerModel); |
| } |
| |
| /** |
| * @return {!Promise<!Array<!Coverage.URLCoverageInfo>>} |
| */ |
| async stop() { |
| await Promise.all([this._stopCSSCoverage(), this._stopJSCoverage()]); |
| return Array.from(this._coverageByURL.values()); |
| } |
| |
| async _stopJSCoverage() { |
| if (!this._cpuProfilerModel) |
| return; |
| var coveragePromise = this._cpuProfilerModel.takePreciseCoverage(); |
| this._cpuProfilerModel.stopPreciseCoverage(); |
| var rawCoverageData = await coveragePromise; |
| this._processJSCoverage(rawCoverageData); |
| } |
| |
| /** |
| * @param {!Array<!Protocol.Profiler.ScriptCoverage>} scriptsCoverage |
| */ |
| _processJSCoverage(scriptsCoverage) { |
| 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); |
| } |
| ranges.sort((a, b) => a.startOffset - b.startOffset); |
| this._addCoverage(script, script.contentLength, script.lineOffset, script.columnOffset, ranges); |
| } |
| } |
| |
| /** |
| * @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.pop(); |
| top = stack.peekLast(); |
| } |
| append(entry.startOffset, top ? top.count : undefined); |
| stack.push(entry); |
| } |
| |
| while (stack.length) { |
| var top = stack.pop(); |
| append(top.endOffset, top.count); |
| } |
| |
| /** |
| * @param {number} end |
| * @param {number} count |
| */ |
| function append(end, count) { |
| var last = result.peekLast(); |
| if (last) { |
| if (last.end === end) |
| return; |
| if (last.count === count) { |
| 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 |
| */ |
| _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); |
| } |
| var segments = Coverage.CoverageModel._convertToDisjointSegments(ranges); |
| entry.update(contentProvider, contentLength, startLine, startColumn, segments); |
| } |
| }; |
| |
| Coverage.URLCoverageInfo = class { |
| /** |
| * @param {string} url |
| */ |
| constructor(url) { |
| this._url = url; |
| /** @type {!Map<string, !Coverage.CoverageInfo>} */ |
| this._coverageInfoByLocation = new Map(); |
| this._size = 0; |
| this._unusedSize = 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; |
| this._unusedSize -= entry._unusedSize; |
| entry.mergeCoverage(segments); |
| this._usedSize += entry._usedSize; |
| this._unusedSize += entry._unusedSize; |
| } |
| |
| /** |
| * @return {string} |
| */ |
| url() { |
| return this._url; |
| } |
| |
| /** |
| * @return {!Coverage.CoverageType} |
| */ |
| type() { |
| return this._type; |
| } |
| |
| /** |
| * @return {number} |
| */ |
| size() { |
| return this._size; |
| } |
| |
| /** |
| * @return {number} |
| */ |
| unusedSize() { |
| return this._unusedSize; |
| } |
| |
| /** |
| * @return {number} |
| */ |
| usedSize() { |
| return this._usedSize; |
| } |
| |
| /** |
| * @return {!Promise<!Array<!{range: !Common.TextRange, count: number}>>} |
| */ |
| async buildTextRanges() { |
| var textRangePromises = []; |
| for (var coverageInfo of this._coverageInfoByLocation.values()) |
| textRangePromises.push(coverageInfo.buildTextRanges()); |
| var allTextRanges = await Promise.all(textRangePromises); |
| return [].concat(...allTextRanges); |
| } |
| }; |
| |
| 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; |
| this._unusedSize = 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 {!Coverage.CoverageType} |
| */ |
| type() { |
| return this._coverageType; |
| } |
| |
| /** |
| * @param {!Array<!Coverage.CoverageSegment>} segments |
| */ |
| mergeCoverage(segments) { |
| this._segments = Coverage.CoverageInfo._mergeCoverage(this._segments, segments); |
| this._updateStats(); |
| } |
| |
| /** |
| * @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]; |
| var b = segmentsB[indexB]; |
| var count = |
| typeof a.count === 'number' || typeof b.count === 'number' ? (a.count || 0) + (b.count || 0) : undefined; |
| var end = Math.min(a.end, b.end); |
| var last = result.peekLast(); |
| 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 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 Common.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; |
| 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; |
| } |
| } |
| }; |