@mcp-b/chrome-devtools-mcp 2.1.0 → 2.2.0

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/handlers/ScreenshotsHandler.js

@@ -1,97 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-// Each thread contains events. Events indicate the thread and process IDs, which are
-// used to store the event in the correct process thread entry below.
-let unpairedAsyncEvents = [];
-let legacyScreenshotEvents = [];
-let modernScreenshotEvents = [];
-let syntheticScreenshots = [];
-let frameSequenceToTs = {};
-export function reset() {
-    unpairedAsyncEvents = [];
-    legacyScreenshotEvents = [];
-    syntheticScreenshots = [];
-    modernScreenshotEvents = [];
-    frameSequenceToTs = {};
-}
-export function handleEvent(event) {
-    if (Types.Events.isLegacyScreenshot(event)) {
-        legacyScreenshotEvents.push(event);
-    }
-    else if (Types.Events.isScreenshot(event)) {
-        modernScreenshotEvents.push(event);
-    }
-    else if (Types.Events.isPipelineReporter(event)) {
-        unpairedAsyncEvents.push(event);
-    }
-}
-export async function finalize() {
-    const pipelineReporterEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(unpairedAsyncEvents);
-    frameSequenceToTs = Object.fromEntries(pipelineReporterEvents.map(evt => {
-        const args = evt.args.data.beginEvent.args;
-        const frameReporter = 'frame_reporter' in args ? args.frame_reporter : args.chrome_frame_reporter;
-        const frameSequenceId = frameReporter.frame_sequence;
-        const presentationTs = Types.Timing.Micro(evt.ts + evt.dur);
-        return [frameSequenceId, presentationTs];
-    }));
-    for (const snapshotEvent of legacyScreenshotEvents) {
-        const { cat, name, ph, pid, tid } = snapshotEvent;
-        const syntheticEvent = Helpers.SyntheticEvents.SyntheticEventsManager.registerSyntheticEvent({
-            rawSourceEvent: snapshotEvent,
-            cat,
-            name,
-            ph,
-            pid,
-            tid,
-            // TODO(paulirish, crbug.com/41363012): investigate why getPresentationTimestamp(snapshotEvent) seems less accurate. Resolve screenshot timing inaccuracy.
-            // `getPresentationTimestamp(snapshotEvent) - snapshotEvent.ts` is how many microsec the screenshot should be adjusted to the right/later
-            ts: snapshotEvent.ts,
-            args: {
-                dataUri: `data:image/jpg;base64,${snapshotEvent.args.snapshot}`,
-            },
-        });
-        syntheticScreenshots.push(syntheticEvent);
-    }
-}
-export function screenshotImageDataUri(event) {
-    if (Types.Events.isLegacySyntheticScreenshot(event)) {
-        return event.args.dataUri;
-    }
-    return `data:image/jpg;base64,${event.args.snapshot}`;
-}
-/**
- * Correct the screenshot timestamps
- * The screenshot 'snapshot object' trace event has the "frame sequence number" attached as an ID.
- * We match that up with the "PipelineReporter" trace events as they terminate at presentation.
- * Presentation == when the pixels hit the screen. AKA Swap on the GPU
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function getPresentationTimestamp(screenshotEvent) {
-    const frameSequence = parseInt(screenshotEvent.id, 16);
-    // If it's 1, then it's an old trace (before https://crrev.com/c/4957973) and cannot be corrected.
-    if (frameSequence === 1) {
-        return screenshotEvent.ts;
-    }
-    // The screenshot trace event's `ts` reflects the "expected display time" which is ESTIMATE.
-    // It is set by the compositor frame sink from the `expected_display_time`, which is based on a previously known
-    // frame start PLUS the vsync interval (eg 16.6ms)
-    const updatedTs = frameSequenceToTs[frameSequence];
-    // Do we always find a match? No...
-    // We generally don't match the very first screenshot and, sometimes, the last
-    // The very first screenshot is requested immediately (even if nothing is painting). As a result there's no compositor
-    // instrumentation running alongside.
-    // The last one is sometimes missing as because the trace terminates right before the associated PipelineReporter is emitted.
-    return updatedTs ?? screenshotEvent.ts;
-}
-export function data() {
-    return {
-        legacySyntheticScreenshots: syntheticScreenshots.length ? syntheticScreenshots : null,
-        screenshots: modernScreenshotEvents.length ? modernScreenshotEvents : null,
-    };
-}
-export function deps() {
-    return ['Meta'];
-}

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/handlers/ScriptsHandler.js

@@ -1,276 +0,0 @@
-// Copyright 2025 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Common from '../../../core/common/common.js';
-import * as Platform from '../../../core/platform/platform.js';
-import * as Types from '../types/types.js';
-import { data as metaHandlerData } from './MetaHandler.js';
-import { data as networkRequestsHandlerData } from './NetworkRequestsHandler.js';
-let scriptById = new Map();
-let frameIdByIsolate = new Map();
-export function deps() {
-    return ['Meta', 'NetworkRequests'];
-}
-export function reset() {
-    scriptById = new Map();
-    frameIdByIsolate = new Map();
-}
-export function handleEvent(event) {
-    const getOrMakeScript = (isolate, scriptIdAsNumber) => {
-        const scriptId = String(scriptIdAsNumber);
-        const key = `${isolate}.${scriptId}`;
-        return Platform.MapUtilities.getWithDefault(scriptById, key, () => ({ isolate, scriptId, frame: '', ts: event.ts }));
-    };
-    if (Types.Events.isRundownScriptCompiled(event) && event.args.data) {
-        const { isolate, scriptId, frame } = event.args.data;
-        const script = getOrMakeScript(isolate, scriptId);
-        script.frame = frame;
-        script.ts = event.ts;
-        return;
-    }
-    if (Types.Events.isRundownScript(event)) {
-        const { isolate, scriptId, url, sourceUrl, sourceMapUrl, sourceMapUrlElided } = event.args.data;
-        const script = getOrMakeScript(isolate, scriptId);
-        if (!script.frame) {
-            script.frame = frameIdByIsolate.get(String(isolate)) ?? '';
-        }
-        script.url = url;
-        script.ts = event.ts;
-        if (sourceUrl) {
-            script.sourceUrl = sourceUrl;
-        }
-        // Older traces may have data source map urls. Those can be very large, so a change
-        // was made to elide them from the trace.
-        // If elided, a fresh trace will fetch the source map from the Script model
-        // (see TimelinePanel getExistingSourceMap). If not fresh, the source map is resolved
-        // instead in this handler via `findCachedRawSourceMap`.
-        if (sourceMapUrlElided) {
-            script.sourceMapUrlElided = true;
-        }
-        else if (sourceMapUrl) {
-            script.sourceMapUrl = sourceMapUrl;
-        }
-        return;
-    }
-    if (Types.Events.isRundownScriptSource(event)) {
-        const { isolate, scriptId, sourceText } = event.args.data;
-        const script = getOrMakeScript(isolate, scriptId);
-        script.content = sourceText;
-        return;
-    }
-    if (Types.Events.isRundownScriptSourceLarge(event)) {
-        const { isolate, scriptId, sourceText } = event.args.data;
-        const script = getOrMakeScript(isolate, scriptId);
-        script.content = (script.content ?? '') + sourceText;
-        return;
-    }
-    // Setup frameIdByIsolate, which is used only in the case that we are missing
-    // rundown events for a script. We won't get a frame association from the rundown
-    // events if the recording started only after the script was first compiled. In
-    // that scenario, derive the frame via the isolate / FunctionCall events.
-    // TODO: ideally, we put the frame on ScriptCatchup event. So much easier. This approach has some
-    // issues.
-    if (Types.Events.isFunctionCall(event) && event.args.data?.isolate && event.args.data.frame) {
-        const { isolate, frame } = event.args.data;
-        const existingValue = frameIdByIsolate.get(isolate);
-        if (existingValue !== frame) {
-            frameIdByIsolate.set(isolate, frame);
-            // Update the scripts we discovered but without knowing their frame.
-            for (const script of scriptById.values()) {
-                if (!script.frame && script.isolate === isolate) {
-                    script.frame = frame;
-                }
-            }
-        }
-    }
-}
-function findFrame(meta, frameId) {
-    for (const frames of meta.frameByProcessId?.values()) {
-        const frame = frames.get(frameId);
-        if (frame) {
-            return frame;
-        }
-    }
-    return null;
-}
-function findNetworkRequest(networkRequests, script) {
-    if (!script.url) {
-        return null;
-    }
-    return networkRequests.find(request => request.args.data.url === script.url) ?? null;
-}
-function computeMappingEndColumns(map) {
-    const result = new Map();
-    const mappings = map.mappings();
-    for (let i = 0; i < mappings.length - 1; i++) {
-        const mapping = mappings[i];
-        const nextMapping = mappings[i + 1];
-        if (mapping.lineNumber === nextMapping.lineNumber) {
-            result.set(mapping, nextMapping.columnNumber);
-        }
-    }
-    // Now, all but the last mapping on each line will have a value in this map.
-    return result;
-}
-/**
- * Using a script's contents and source map, attribute every generated byte to an authored source file.
- */
-function computeGeneratedFileSizes(script) {
-    if (!script.sourceMap) {
-        throw new Error('expected source map');
-    }
-    const map = script.sourceMap;
-    const content = script.content ?? '';
-    const contentLength = content.length;
-    const lines = content.split('\n');
-    const files = {};
-    const totalBytes = contentLength;
-    let unmappedBytes = totalBytes;
-    const mappingEndCols = computeMappingEndColumns(script.sourceMap);
-    for (const mapping of map.mappings()) {
-        const source = mapping.sourceURL;
-        const lineNum = mapping.lineNumber;
-        const colNum = mapping.columnNumber;
-        const lastColNum = mappingEndCols.get(mapping);
-        // Webpack sometimes emits null mappings.
-        // https://github.com/mozilla/source-map/pull/303
-        if (!source) {
-            continue;
-        }
-        // Lines and columns are zero-based indices. Visually, lines are shown as a 1-based index.
-        const line = lines[lineNum];
-        if (line === null || line === undefined) {
-            const errorMessage = `${map.url()} mapping for line out of bounds: ${lineNum + 1}`;
-            return { errorMessage };
-        }
-        if (colNum > line.length) {
-            const errorMessage = `${map.url()} mapping for column out of bounds: ${lineNum + 1}:${colNum}`;
-            return { errorMessage };
-        }
-        let mappingLength = 0;
-        if (lastColNum !== undefined) {
-            if (lastColNum > line.length) {
-                const errorMessage = `${map.url()} mapping for last column out of bounds: ${lineNum + 1}:${lastColNum}`;
-                return { errorMessage };
-            }
-            mappingLength = lastColNum - colNum;
-        }
-        else {
-            // Add +1 to account for the newline.
-            mappingLength = line.length - colNum + 1;
-        }
-        files[source] = (files[source] || 0) + mappingLength;
-        unmappedBytes -= mappingLength;
-    }
-    return {
-        files,
-        unmappedBytes,
-        totalBytes,
-    };
-}
-export function getScriptGeneratedSizes(script) {
-    if (script.sourceMap && !script.sizes) {
-        script.sizes = computeGeneratedFileSizes(script);
-    }
-    return script.sizes ?? null;
-}
-function findCachedRawSourceMap(script, options) {
-    if (options.isFreshRecording || !options.metadata?.sourceMaps) {
-        // Exit if this is not a loaded trace w/ source maps in the metadata.
-        return;
-    }
-    // For elided data url source maps, search the metadata source maps by script url.
-    if (script.sourceMapUrlElided) {
-        if (!script.url) {
-            return;
-        }
-        const cachedSourceMap = options.metadata.sourceMaps.find(m => m.url === script.url);
-        if (cachedSourceMap) {
-            return cachedSourceMap.sourceMap;
-        }
-        return;
-    }
-    if (!script.sourceMapUrl) {
-        return;
-    }
-    // Otherwise, search by source map url.
-    // Note: early enhanced traces may have this field set for data urls. Ignore those,
-    // as they were never stored in metadata sourcemap.
-    const isDataUrl = script.sourceMapUrl.startsWith('data:');
-    if (!isDataUrl) {
-        const cachedSourceMap = options.metadata.sourceMaps.find(m => m.sourceMapUrl === script.sourceMapUrl);
-        if (cachedSourceMap) {
-            return cachedSourceMap.sourceMap;
-        }
-    }
-    return;
-}
-export async function finalize(options) {
-    const meta = metaHandlerData();
-    const networkRequests = [...networkRequestsHandlerData().byId.values()];
-    const documentUrls = new Set();
-    for (const frames of meta.frameByProcessId.values()) {
-        for (const frame of frames.values()) {
-            documentUrls.add(frame.url);
-        }
-    }
-    for (const script of scriptById.values()) {
-        script.request = findNetworkRequest(networkRequests, script) ?? undefined;
-        script.inline = !!script.url && documentUrls.has(script.url);
-    }
-    if (!options.resolveSourceMap) {
-        return;
-    }
-    const promises = [];
-    for (const script of scriptById.values()) {
-        // No frame or url means the script came from somewhere we don't care about.
-        // Note: scripts from inline <SCRIPT> elements use the url of the HTML document,
-        // so aren't ignored.
-        if (!script.frame || !script.url || (!script.sourceMapUrl && !script.sourceMapUrlElided)) {
-            continue;
-        }
-        const frameUrl = findFrame(meta, script.frame)?.url;
-        if (!frameUrl) {
-            continue;
-        }
-        // If there is a `sourceURL` magic comment, resolve the compiledUrl against the frame url.
-        // example: `// #sourceURL=foo.js` for target frame https://www.example.com/home -> https://www.example.com/home/foo.js
-        let sourceUrl = script.url;
-        if (script.sourceUrl) {
-            sourceUrl = Common.ParsedURL.ParsedURL.completeURL(frameUrl, script.sourceUrl) ?? script.sourceUrl;
-        }
-        let sourceMapUrl;
-        if (script.sourceMapUrl) {
-            // Resolve the source map url. The value given by v8 may be relative, so resolve it here.
-            // This process should match the one in `SourceMapManager.attachSourceMap`.
-            sourceMapUrl =
-                Common.ParsedURL.ParsedURL.completeURL(sourceUrl, script.sourceMapUrl);
-            if (!sourceMapUrl) {
-                continue;
-            }
-            script.sourceMapUrl = sourceMapUrl;
-        }
-        const params = {
-            scriptId: script.scriptId,
-            scriptUrl: script.url,
-            sourceUrl: sourceUrl,
-            sourceMapUrl: sourceMapUrl ?? '',
-            frame: script.frame,
-            cachedRawSourceMap: findCachedRawSourceMap(script, options),
-        };
-        const promise = options.resolveSourceMap(params).then(sourceMap => {
-            if (sourceMap) {
-                script.sourceMap = sourceMap;
-            }
-        });
-        promises.push(promise.catch(e => {
-            console.error('Uncaught error when resolving source map', params, e);
-        }));
-    }
-    await Promise.all(promises);
-}
-export function data() {
-    return {
-        scripts: [...scriptById.values()],
-    };
-}

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/handlers/SelectorStatsHandler.js

@@ -1,71 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Types from '../types/types.js';
-let lastRecalcStyleEvent = null;
-let lastInvalidatedNode = null;
-let selectorDataForRecalcStyle = new Map();
-let invalidatedNodeList = new Array();
-export function reset() {
-    lastRecalcStyleEvent = null;
-    lastInvalidatedNode = null;
-    selectorDataForRecalcStyle = new Map();
-    invalidatedNodeList = [];
-}
-export function handleEvent(event) {
-    if (Types.Events.isStyleRecalcInvalidationTracking(event)) {
-        /**
-         * CSS Style substree invalidation
-         * A subtree invalidation comes with two records, 1) a StyleInvalidatorInvalidationTracking
-         * event 2) following with a StyleRecalcInvalidationTracking event. List of selectors and style
-         * sheet ID information is stored in the 1st event. Subtree flag is stored in the 2nd
-         * event.
-         */
-        if (event.args.data.subtree &&
-            event.args.data.reason === "Related style rule" /* Types.Events.StyleRecalcInvalidationReason.RELATED_STYLE_RULE */ &&
-            lastInvalidatedNode && event.args.data.nodeId === lastInvalidatedNode.backendNodeId) {
-            lastInvalidatedNode.subtree = true;
-            return;
-        }
-    }
-    if (Types.Events.isSelectorStats(event) && lastRecalcStyleEvent && event.args.selector_stats) {
-        selectorDataForRecalcStyle.set(lastRecalcStyleEvent, {
-            timings: event.args.selector_stats.selector_timings,
-        });
-        return;
-    }
-    if (Types.Events.isStyleInvalidatorInvalidationTracking(event)) {
-        const selectorList = new Array();
-        event.args.data.selectors?.forEach(selector => {
-            selectorList.push({
-                selector: selector.selector,
-                styleSheetId: selector.style_sheet_id,
-            });
-        });
-        if (selectorList.length > 0) {
-            lastInvalidatedNode = {
-                frame: event.args.data.frame,
-                backendNodeId: event.args.data.nodeId,
-                type: "StyleInvalidatorInvalidationTracking" /* Types.Events.InvalidationEventType.StyleInvalidatorInvalidationTracking */,
-                selectorList,
-                ts: event.ts,
-                tts: event.tts,
-                subtree: false,
-                lastRecalcStyleEventTs: lastRecalcStyleEvent ? lastRecalcStyleEvent.ts : Types.Timing.Micro(0),
-            };
-            invalidatedNodeList.push(lastInvalidatedNode);
-        }
-    }
-    if (Types.Events.isRecalcStyle(event)) {
-        lastRecalcStyleEvent = event;
-        return;
-    }
-}
-export async function finalize() {
-}
-export function data() {
-    return {
-        dataForRecalcStyleEvent: selectorDataForRecalcStyle,
-        invalidatedNodeList,
-    };
-}

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/handlers/Threads.js

@@ -1,101 +0,0 @@
-function getThreadTypeForRendererThread(pid, thread, auctionWorkletsData) {
-    let threadType = "OTHER" /* ThreadType.OTHER */;
-    if (thread.name === 'CrRendererMain') {
-        threadType = "MAIN_THREAD" /* ThreadType.MAIN_THREAD */;
-    }
-    else if (thread.name === 'DedicatedWorker thread') {
-        threadType = "WORKER" /* ThreadType.WORKER */;
-    }
-    else if (thread.name?.startsWith('CompositorTileWorker')) {
-        threadType = "RASTERIZER" /* ThreadType.RASTERIZER */;
-    }
-    else if (auctionWorkletsData.worklets.has(pid)) {
-        threadType = "AUCTION_WORKLET" /* ThreadType.AUCTION_WORKLET */;
-    }
-    else if (thread.name?.startsWith('ThreadPool')) {
-        // TODO(paulirish): perhaps exclude ThreadPoolServiceThread entirely
-        threadType = "THREAD_POOL" /* ThreadType.THREAD_POOL */;
-    }
-    return threadType;
-}
-export function threadsInRenderer(rendererData, auctionWorkletsData) {
-    const foundThreads = [];
-    // If we have Renderer threads, we prefer to use those. In the event that a
-    // trace is a CPU Profile trace, we will never have Renderer threads, so we
-    // know if there are no Renderer threads that we can fallback to using the
-    // data from the SamplesHandler.
-    if (rendererData.processes.size) {
-        for (const [pid, process] of rendererData.processes) {
-            for (const [tid, thread] of process.threads) {
-                if (!thread.tree) {
-                    // Drop threads where we could not create the tree; this indicates
-                    // unexpected data and we won't be able to support all the UI
-                    // filtering we need.
-                    continue;
-                }
-                const threadType = getThreadTypeForRendererThread(pid, thread, auctionWorkletsData);
-                foundThreads.push({
-                    name: thread.name,
-                    pid,
-                    tid,
-                    processIsOnMainFrame: process.isOnMainFrame,
-                    entries: thread.entries,
-                    tree: thread.tree,
-                    type: threadType,
-                    entryToNode: rendererData.entryToNode,
-                });
-            }
-        }
-    }
-    return foundThreads;
-}
-const threadsInHandlerDataCache = new WeakMap();
-/**
- * Given trace parsed data, this helper will return a high level array of
- * ThreadData. This is useful because it allows you to get a list of threads
- * regardless of if the trace is a CPU Profile or a Tracing profile. Thus you
- * can use this helper to iterate over threads in confidence that it will work
- * for both trace types.
- * The resulting data is cached per-trace, so you can safely call this multiple times.
- */
-export function threadsInTrace(handlerData) {
-    const cached = threadsInHandlerDataCache.get(handlerData);
-    if (cached) {
-        return cached;
-    }
-    // If we have Renderer threads, we prefer to use those.
-    const threadsFromRenderer = threadsInRenderer(handlerData.Renderer, handlerData.AuctionWorklets);
-    if (threadsFromRenderer.length) {
-        threadsInHandlerDataCache.set(handlerData, threadsFromRenderer);
-        return threadsFromRenderer;
-    }
-    // If it's a CPU Profile trace, there will be no Renderer threads.
-    // We can fallback to using the data from the SamplesHandler.
-    const foundThreads = [];
-    if (handlerData.Samples.profilesInProcess.size) {
-        for (const [pid, process] of handlerData.Samples.profilesInProcess) {
-            for (const [tid, thread] of process) {
-                if (!thread.profileTree) {
-                    // Drop threads where we could not create the tree; this indicates
-                    // unexpected data and we won't be able to support all the UI
-                    // filtering we need.
-                    continue;
-                }
-                foundThreads.push({
-                    pid,
-                    tid,
-                    // CPU Profile threads do not have a name.
-                    name: null,
-                    entries: thread.profileCalls,
-                    // There is no concept of a "Main Frame" in a CPU profile.
-                    processIsOnMainFrame: false,
-                    tree: thread.profileTree,
-                    type: "CPU_PROFILE" /* ThreadType.CPU_PROFILE */,
-                    entryToNode: handlerData.Samples.entryToNode,
-                });
-            }
-        }
-    }
-    threadsInHandlerDataCache.set(handlerData, foundThreads);
-    return foundThreads;
-}