chrome-devtools-mcp 0.0.1 → 0.0.2

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/LanternComputationData.js

@@ -0,0 +1,370 @@
+// 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 Handlers from './handlers/handlers.js';
+import * as Lantern from './lantern/lantern.js';
+function createProcessedNavigation(data, frameId, navigationId) {
+    const scoresByNav = data.PageLoadMetrics.metricScoresByFrameId.get(frameId);
+    if (!scoresByNav) {
+        throw new Lantern.Core.LanternError('missing metric scores for frame');
+    }
+    const scores = scoresByNav.get(navigationId);
+    if (!scores) {
+        throw new Lantern.Core.LanternError('missing metric scores for specified navigation');
+    }
+    const getTimestampOrUndefined = (metric) => {
+        const metricScore = scores.get(metric);
+        if (!metricScore?.event) {
+            return;
+        }
+        return metricScore.event.ts;
+    };
+    const getTimestamp = (metric) => {
+        const metricScore = scores.get(metric);
+        if (!metricScore?.event) {
+            throw new Lantern.Core.LanternError(`missing metric: ${metric}`);
+        }
+        return metricScore.event.ts;
+    };
+    return {
+        timestamps: {
+            firstContentfulPaint: getTimestamp("FCP" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.FCP */),
+            largestContentfulPaint: getTimestampOrUndefined("LCP" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.LCP */),
+        },
+    };
+}
+function createParsedUrl(url) {
+    if (typeof url === 'string') {
+        url = new URL(url);
+    }
+    return {
+        scheme: url.protocol.split(':')[0],
+        // Intentional, DevTools uses different terminology
+        host: url.hostname,
+        securityOrigin: url.origin,
+    };
+}
+/**
+ * Returns a map of `pid` -> `tid[]`.
+ */
+function findWorkerThreads(trace) {
+    // TODO: WorkersHandler in Trace Engine needs to be updated to also include `pid` (only had `tid`).
+    const workerThreads = new Map();
+    const workerCreationEvents = ['ServiceWorker thread', 'DedicatedWorker thread'];
+    for (const event of trace.traceEvents) {
+        if (event.name !== 'thread_name' || !event.args.name) {
+            continue;
+        }
+        if (!workerCreationEvents.includes(event.args.name)) {
+            continue;
+        }
+        const tids = workerThreads.get(event.pid);
+        if (tids) {
+            tids.push(event.tid);
+        }
+        else {
+            workerThreads.set(event.pid, [event.tid]);
+        }
+    }
+    return workerThreads;
+}
+function createLanternRequest(parsedTrace, workerThreads, request) {
+    if (request.args.data.hasResponse && request.args.data.connectionId === undefined) {
+        throw new Lantern.Core.LanternError('Trace is too old');
+    }
+    let url;
+    try {
+        url = new URL(request.args.data.url);
+    }
+    catch {
+        return;
+    }
+    const timing = request.args.data.timing ? {
+        // These two timings are not included in the trace.
+        workerFetchStart: -1,
+        workerRespondWithSettled: -1,
+        receiveHeadersStart: -1,
+        ...request.args.data.timing,
+    } :
+        undefined;
+    const networkRequestTime = timing ? timing.requestTime * 1000 : request.args.data.syntheticData.downloadStart / 1000;
+    let fromWorker = false;
+    const tids = workerThreads.get(request.pid);
+    if (tids?.includes(request.tid)) {
+        fromWorker = true;
+    }
+    // Trace Engine collects worker thread ids in a different manner than `workerThreads` does.
+    // AFAIK these should be equivalent, but in case they are not let's also check this for now.
+    if (parsedTrace.Workers.workerIdByThread.has(request.tid)) {
+        fromWorker = true;
+    }
+    // `initiator` in the trace does not contain the stack trace for JS-initiated
+    // requests. Instead, that is stored in the `stackTrace` property of the SyntheticNetworkRequest.
+    // There are some minor differences in the fields, accounted for here.
+    // Most importantly, there seems to be fewer frames in the trace than the equivalent
+    // events over the CDP. This results in less accuracy in determining the initiator request,
+    // which means less edges in the graph, which mean worse results.
+    // TODO: Should fix in Chromium.
+    const initiator = request.args.data.initiator ?? { type: "other" /* Protocol.Network.InitiatorType.Other */ };
+    if (request.args.data.stackTrace) {
+        const callFrames = request.args.data.stackTrace.map(f => {
+            return {
+                scriptId: String(f.scriptId),
+                url: f.url,
+                lineNumber: f.lineNumber - 1,
+                columnNumber: f.columnNumber - 1,
+                functionName: f.functionName,
+            };
+        });
+        initiator.stack = { callFrames };
+        // Note: there is no `parent` to set ...
+    }
+    let resourceType = request.args.data.resourceType;
+    if (request.args.data.initiator?.fetchType === 'xmlhttprequest') {
+        // @ts-expect-error yes XHR is a valid ResourceType. TypeScript const enums are so unhelpful.
+        resourceType = 'XHR';
+    }
+    else if (request.args.data.initiator?.fetchType === 'fetch') {
+        // @ts-expect-error yes Fetch is a valid ResourceType. TypeScript const enums are so unhelpful.
+        resourceType = 'Fetch';
+    }
+    // TODO: set decodedBodyLength for data urls in Trace Engine.
+    let resourceSize = request.args.data.decodedBodyLength ?? 0;
+    if (url.protocol === 'data:' && resourceSize === 0) {
+        const commaIndex = url.pathname.indexOf(',');
+        if (url.pathname.substring(0, commaIndex).includes(';base64')) {
+            resourceSize = atob(url.pathname.substring(commaIndex + 1)).length;
+        }
+        else {
+            resourceSize = url.pathname.length - commaIndex - 1;
+        }
+    }
+    return {
+        rawRequest: request,
+        requestId: request.args.data.requestId,
+        connectionId: request.args.data.connectionId ?? 0,
+        connectionReused: request.args.data.connectionReused ?? false,
+        url: request.args.data.url,
+        protocol: request.args.data.protocol,
+        parsedURL: createParsedUrl(url),
+        documentURL: request.args.data.requestingFrameUrl,
+        rendererStartTime: request.ts / 1000,
+        networkRequestTime,
+        responseHeadersEndTime: request.args.data.syntheticData.downloadStart / 1000,
+        networkEndTime: request.args.data.syntheticData.finishTime / 1000,
+        transferSize: request.args.data.encodedDataLength,
+        resourceSize,
+        fromDiskCache: request.args.data.syntheticData.isDiskCached,
+        fromMemoryCache: request.args.data.syntheticData.isMemoryCached,
+        isLinkPreload: request.args.data.isLinkPreload,
+        finished: request.args.data.finished,
+        failed: request.args.data.failed,
+        statusCode: request.args.data.statusCode,
+        initiator,
+        timing,
+        resourceType,
+        mimeType: request.args.data.mimeType,
+        priority: request.args.data.priority,
+        frameId: request.args.data.frame,
+        fromWorker,
+        // Set later.
+        redirects: undefined,
+        redirectSource: undefined,
+        redirectDestination: undefined,
+        initiatorRequest: undefined,
+    };
+}
+/**
+ * @param request The request to find the initiator of
+ */
+function chooseInitiatorRequest(request, requestsByURL) {
+    if (request.redirectSource) {
+        return request.redirectSource;
+    }
+    const initiatorURL = Lantern.Graph.PageDependencyGraph.getNetworkInitiators(request)[0];
+    let candidates = requestsByURL.get(initiatorURL) || [];
+    // The (valid) initiator must come before the initiated request.
+    candidates = candidates.filter(c => {
+        return c.responseHeadersEndTime <= request.rendererStartTime && c.finished && !c.failed;
+    });
+    if (candidates.length > 1) {
+        // Disambiguate based on prefetch. Prefetch requests have type 'Other' and cannot
+        // initiate requests, so we drop them here.
+        const nonPrefetchCandidates = candidates.filter(cand => cand.resourceType !== Lantern.Types.NetworkRequestTypes.Other);
+        if (nonPrefetchCandidates.length) {
+            candidates = nonPrefetchCandidates;
+        }
+    }
+    if (candidates.length > 1) {
+        // Disambiguate based on frame. It's likely that the initiator comes from the same frame.
+        const sameFrameCandidates = candidates.filter(cand => cand.frameId === request.frameId);
+        if (sameFrameCandidates.length) {
+            candidates = sameFrameCandidates;
+        }
+    }
+    if (candidates.length > 1 && request.initiator.type === 'parser') {
+        // Filter to just Documents when initiator type is parser.
+        const documentCandidates = candidates.filter(cand => cand.resourceType === Lantern.Types.NetworkRequestTypes.Document);
+        if (documentCandidates.length) {
+            candidates = documentCandidates;
+        }
+    }
+    if (candidates.length > 1) {
+        // If all real loads came from successful preloads (url preloaded and
+        // loads came from the cache), filter to link rel=preload request(s).
+        const linkPreloadCandidates = candidates.filter(c => c.isLinkPreload);
+        if (linkPreloadCandidates.length) {
+            const nonPreloadCandidates = candidates.filter(c => !c.isLinkPreload);
+            const allPreloaded = nonPreloadCandidates.every(c => c.fromDiskCache || c.fromMemoryCache);
+            if (nonPreloadCandidates.length && allPreloaded) {
+                candidates = linkPreloadCandidates;
+            }
+        }
+    }
+    // Only return an initiator if the result is unambiguous.
+    return candidates.length === 1 ? candidates[0] : null;
+}
+function linkInitiators(lanternRequests) {
+    const requestsByURL = new Map();
+    for (const request of lanternRequests) {
+        const requests = requestsByURL.get(request.url) || [];
+        requests.push(request);
+        requestsByURL.set(request.url, requests);
+    }
+    for (const request of lanternRequests) {
+        const initiatorRequest = chooseInitiatorRequest(request, requestsByURL);
+        if (initiatorRequest) {
+            request.initiatorRequest = initiatorRequest;
+        }
+    }
+}
+function createNetworkRequests(trace, data, startTime = 0, endTime = Number.POSITIVE_INFINITY) {
+    const workerThreads = findWorkerThreads(trace);
+    const lanternRequestsNoRedirects = [];
+    for (const request of data.NetworkRequests.byTime) {
+        if (request.ts >= startTime && request.ts < endTime) {
+            const lanternRequest = createLanternRequest(data, workerThreads, request);
+            if (lanternRequest) {
+                lanternRequestsNoRedirects.push(lanternRequest);
+            }
+        }
+    }
+    const lanternRequests = [];
+    // Trace Engine consolidates all redirects into a single request object, but lantern needs
+    // an entry for each redirected request.
+    for (const request of [...lanternRequestsNoRedirects]) {
+        if (!request.rawRequest) {
+            continue;
+        }
+        const redirects = request.rawRequest.args.data.redirects;
+        if (!redirects.length) {
+            lanternRequests.push(request);
+            continue;
+        }
+        const requestChain = [];
+        for (const redirect of redirects) {
+            const redirectedRequest = structuredClone(request);
+            redirectedRequest.networkRequestTime = redirect.ts / 1000;
+            redirectedRequest.rendererStartTime = redirectedRequest.networkRequestTime;
+            redirectedRequest.networkEndTime = (redirect.ts + redirect.dur) / 1000;
+            redirectedRequest.responseHeadersEndTime = redirectedRequest.networkEndTime;
+            redirectedRequest.timing = {
+                requestTime: redirectedRequest.networkRequestTime / 1000,
+                receiveHeadersStart: redirectedRequest.responseHeadersEndTime,
+                receiveHeadersEnd: redirectedRequest.responseHeadersEndTime,
+                proxyStart: -1,
+                proxyEnd: -1,
+                dnsStart: -1,
+                dnsEnd: -1,
+                connectStart: -1,
+                connectEnd: -1,
+                sslStart: -1,
+                sslEnd: -1,
+                sendStart: -1,
+                sendEnd: -1,
+                workerStart: -1,
+                workerReady: -1,
+                workerFetchStart: -1,
+                workerRespondWithSettled: -1,
+                pushStart: -1,
+                pushEnd: -1,
+            };
+            redirectedRequest.url = redirect.url;
+            redirectedRequest.parsedURL = createParsedUrl(redirect.url);
+            // TODO: Trace Engine is not retaining the actual status code.
+            redirectedRequest.statusCode = 302;
+            redirectedRequest.resourceType = undefined;
+            // TODO: Trace Engine is not retaining transfer size of redirected request.
+            redirectedRequest.transferSize = 400;
+            requestChain.push(redirectedRequest);
+            lanternRequests.push(redirectedRequest);
+        }
+        requestChain.push(request);
+        lanternRequests.push(request);
+        for (let i = 0; i < requestChain.length; i++) {
+            const request = requestChain[i];
+            if (i > 0) {
+                request.redirectSource = requestChain[i - 1];
+                request.redirects = requestChain.slice(0, i);
+            }
+            if (i !== requestChain.length - 1) {
+                request.redirectDestination = requestChain[i + 1];
+            }
+        }
+        // Apply the `:redirect` requestId convention: only redirects[0].requestId is the actual
+        // requestId, all the rest have n occurrences of `:redirect` as a suffix.
+        for (let i = 1; i < requestChain.length; i++) {
+            requestChain[i].requestId = `${requestChain[i - 1].requestId}:redirect`;
+        }
+    }
+    linkInitiators(lanternRequests);
+    return lanternRequests;
+}
+function collectMainThreadEvents(trace, data) {
+    const Meta = data.Meta;
+    const mainFramePids = Meta.mainFrameNavigations.length ? new Set(Meta.mainFrameNavigations.map(nav => nav.pid)) :
+        Meta.topLevelRendererIds;
+    const rendererPidToTid = new Map();
+    for (const pid of mainFramePids) {
+        const threads = Meta.threadsInProcess.get(pid) ?? [];
+        let found = false;
+        for (const [tid, thread] of threads) {
+            if (thread.args.name === 'CrRendererMain') {
+                rendererPidToTid.set(pid, tid);
+                found = true;
+                break;
+            }
+        }
+        if (found) {
+            continue;
+        }
+        // `CrRendererMain` can be missing if chrome is launched with the `--single-process` flag.
+        // In this case, page tasks will be run in the browser thread.
+        for (const [tid, thread] of threads) {
+            if (thread.args.name === 'CrBrowserMain') {
+                rendererPidToTid.set(pid, tid);
+                found = true;
+                break;
+            }
+        }
+    }
+    return trace.traceEvents.filter(e => rendererPidToTid.get(e.pid) === e.tid);
+}
+function createGraph(requests, trace, data, url) {
+    const mainThreadEvents = collectMainThreadEvents(trace, data);
+    // url defines the initial request that the Lantern graph starts at (the root node) and the
+    // main document request. These are equal if there are no redirects.
+    if (!url) {
+        url = {
+            requestedUrl: requests[0].url,
+            mainDocumentUrl: '',
+        };
+        let request = requests[0];
+        while (request.redirectDestination) {
+            request = request.redirectDestination;
+        }
+        url.mainDocumentUrl = request.url;
+    }
+    return Lantern.Graph.PageDependencyGraph.createGraph(mainThreadEvents, requests, url);
+}
+export { createGraph, createNetworkRequests, createProcessedNavigation, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/ModelImpl.js

@@ -0,0 +1,171 @@
+// 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 Platform from '../../core/platform/platform.js';
+import * as Handlers from './handlers/handlers.js';
+import * as Helpers from './helpers/helpers.js';
+import { TraceParseProgressEvent, TraceProcessor } from './Processor.js';
+import * as Types from './types/types.js';
+/**
+ * The Model is responsible for parsing arrays of raw trace events and storing the
+ * resulting data. It can store multiple traces at once, and can return the data for
+ * any of them.
+ *
+ * Most uses of this class should be through `createWithAllHandlers`, but
+ * `createWithSubsetOfHandlers` can be used to run just some handlers.
+ **/
+export class Model extends EventTarget {
+    #traces = [];
+    #nextNumberByDomain = new Map();
+    #recordingsAvailable = [];
+    #lastRecordingIndex = 0;
+    #processor;
+    #config = Types.Configuration.defaults();
+    static createWithAllHandlers(config) {
+        return new Model(Handlers.ModelHandlers, config);
+    }
+    /**
+     * Runs only the provided handlers.
+     *
+     * Callers must ensure they are providing all dependant handlers (although Meta is included automatically),
+     * and must know that the result of `.parsedTrace` will be limited to the handlers provided, even though
+     * the type won't reflect that.
+     */
+    static createWithSubsetOfHandlers(traceHandlers, config) {
+        return new Model(traceHandlers, config);
+    }
+    constructor(handlers, config) {
+        super();
+        if (config) {
+            this.#config = config;
+        }
+        this.#processor = new TraceProcessor(handlers, this.#config);
+    }
+    /**
+     * Parses an array of trace events into a structured object containing all the
+     * information parsed by the trace handlers.
+     * You can `await` this function to pause execution until parsing is complete,
+     * or instead rely on the `ModuleUpdateEvent` that is dispatched when the
+     * parsing is finished.
+     *
+     * Once parsed, you then have to call the `parsedTrace` method, providing an
+     * index of the trace you want to have the data for. This is because any model
+     * can store a number of traces. Each trace is given an index, which starts at 0
+     * and increments by one as a new trace is parsed.
+     *
+     * @example
+     * // Awaiting the parse method() to block until parsing complete
+     * await this.traceModel.parse(events);
+     * const data = this.traceModel.parsedTrace(0)
+     * @example
+     * // Using an event listener to be notified when tracing is complete.
+     * this.traceModel.addEventListener(Trace.ModelUpdateEvent.eventName, (event) => {
+     *   if(event.data.data === 'done') {
+     *     // trace complete
+     *     const data = this.traceModel.parsedTrace(0);
+     *   }
+     * });
+     * void this.traceModel.parse(events);
+     **/
+    async parse(traceEvents, config) {
+        const metadata = config?.metadata || {};
+        const isFreshRecording = config?.isFreshRecording || false;
+        const isCPUProfile = metadata?.dataOrigin === "CPUProfile" /* Types.File.DataOrigin.CPU_PROFILE */;
+        // During parsing, periodically update any listeners on each processors'
+        // progress (if they have any updates).
+        const onTraceUpdate = (event) => {
+            const { data } = event;
+            this.dispatchEvent(new ModelUpdateEvent({ type: "PROGRESS_UPDATE" /* ModelUpdateType.PROGRESS_UPDATE */, data }));
+        };
+        this.#processor.addEventListener(TraceParseProgressEvent.eventName, onTraceUpdate);
+        // TODO(cjamcl): this.#processor.parse needs this to work. So it should either take it as input, or create it itself.
+        const syntheticEventsManager = Helpers.SyntheticEvents.SyntheticEventsManager.createAndActivate(traceEvents);
+        try {
+            // Wait for all outstanding promises before finishing the async execution,
+            // but perform all tasks in parallel.
+            const parseConfig = {
+                isFreshRecording,
+                isCPUProfile,
+                metadata,
+                resolveSourceMap: config?.resolveSourceMap,
+            };
+            await this.#processor.parse(traceEvents, parseConfig);
+            if (!this.#processor.data) {
+                throw new Error('processor did not parse trace');
+            }
+            const file = this.#storeAndCreateParsedTraceFile(syntheticEventsManager, traceEvents, metadata, this.#processor.data, this.#processor.insights);
+            // We only push the file onto this.#traces here once we know it's valid
+            // and there's been no errors in the parsing.
+            this.#traces.push(file);
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            // All processors have finished parsing, no more updates are expected.
+            this.#processor.removeEventListener(TraceParseProgressEvent.eventName, onTraceUpdate);
+            // Finally, update any listeners that all processors are 'done'.
+            this.dispatchEvent(new ModelUpdateEvent({ type: "COMPLETE" /* ModelUpdateType.COMPLETE */, data: 'done' }));
+        }
+    }
+    #storeAndCreateParsedTraceFile(syntheticEventsManager, traceEvents, metadata, data, traceInsights) {
+        this.#lastRecordingIndex++;
+        let recordingName = `Trace ${this.#lastRecordingIndex}`;
+        const origin = Helpers.Trace.extractOriginFromTrace(data.Meta.mainFrameURL);
+        if (origin) {
+            const nextSequenceForDomain = Platform.MapUtilities.getWithDefault(this.#nextNumberByDomain, origin, () => 1);
+            recordingName = `${origin} (${nextSequenceForDomain})`;
+            this.#nextNumberByDomain.set(origin, nextSequenceForDomain + 1);
+        }
+        this.#recordingsAvailable.push(recordingName);
+        return {
+            traceEvents,
+            metadata,
+            data,
+            insights: traceInsights,
+            syntheticEventsManager,
+        };
+    }
+    lastTraceIndex() {
+        return this.size() - 1;
+    }
+    /**
+     * Returns the parsed trace data indexed by the order in which it was stored.
+     * If no index is given, the last stored parsed data is returned.
+     */
+    parsedTrace(index = this.#traces.length - 1) {
+        return this.#traces.at(index) ?? null;
+    }
+    overrideModifications(index, newModifications) {
+        if (this.#traces[index]) {
+            this.#traces[index].metadata.modifications = newModifications;
+        }
+    }
+    syntheticTraceEventsManager(index = this.#traces.length - 1) {
+        return this.#traces.at(index)?.syntheticEventsManager ?? null;
+    }
+    size() {
+        return this.#traces.length;
+    }
+    deleteTraceByIndex(recordingIndex) {
+        this.#traces.splice(recordingIndex, 1);
+        this.#recordingsAvailable.splice(recordingIndex, 1);
+    }
+    getRecordingsAvailable() {
+        return this.#recordingsAvailable;
+    }
+    resetProcessor() {
+        this.#processor.reset();
+    }
+}
+export class ModelUpdateEvent extends Event {
+    data;
+    static eventName = 'modelupdate';
+    constructor(data) {
+        super(ModelUpdateEvent.eventName);
+        this.data = data;
+    }
+}
+export function isModelUpdateDataComplete(eventData) {
+    return eventData.type === "COMPLETE" /* ModelUpdateType.COMPLETE */;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/Name.js

@@ -0,0 +1,114 @@
+// 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 Common from '../../core/common/common.js';
+import * as i18n from '../../core/i18n/i18n.js';
+import * as Handlers from './handlers/handlers.js';
+import { getEventStyle } from './Styles.js';
+import * as Types from './types/types.js';
+const UIStrings = {
+    /**
+     * @description Text shown for an entry in the flame chart that has no explicit name.
+     */
+    anonymous: '(anonymous)',
+    /**
+     * @description Text used to show an EventDispatch event which has a type associated with it
+     * @example {click} PH1
+     */
+    eventDispatchS: 'Event: {PH1}',
+    /**
+     * @description Text shown for an entry in the flame chart that represents a frame.
+     */
+    frame: 'Frame',
+    /**
+     * @description Text in Timeline Flame Chart Data Provider of the Performance panel
+     */
+    wsConnectionOpened: 'WebSocket opened',
+    /**
+     * @description Text in Timeline Flame Chart Data Provider of the Performance panel
+     * @example {ws://example.com} PH1
+     */
+    wsConnectionOpenedWithUrl: 'WebSocket opened: {PH1}',
+    /**
+     * @description Text in Timeline Flame Chart Data Provider of the Performance panel
+     */
+    wsConnectionClosed: 'WebSocket closed',
+    /**
+     * @description Text in Timeline Flame Chart Data Provider of the Performance panel
+     */
+    layoutShift: 'Layout shift',
+};
+const str_ = i18n.i18n.registerUIStrings('models/trace/Name.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+/**
+ * Calculates the display name for a given entry.
+ * @param parsedTrace If the trace data is provided
+ * as the second argument it can be used to find source map resolved names for
+ * profile calls.
+ * Use this function to customize the user visible name for an entry. If no
+ * custom name is found, we will fallback to the `name` property in the trace
+ * entry.
+ */
+export function forEntry(entry, parsedTrace) {
+    if (Types.Events.isProfileCall(entry)) {
+        if (parsedTrace) {
+            const potentialCallName = Handlers.ModelHandlers.Samples.getProfileCallFunctionName(parsedTrace.data.Samples, entry);
+            // We need this extra check because the call name could be the empty
+            // string. If it is, we want to fallback.
+            if (potentialCallName) {
+                return potentialCallName;
+            }
+        }
+        return entry.callFrame.functionName || i18nString(UIStrings.anonymous);
+    }
+    if (Types.Events.isLegacyTimelineFrame(entry)) {
+        return i18n.i18n.lockedString(UIStrings.frame);
+    }
+    if (Types.Events.isDispatch(entry)) {
+        // EventDispatch represent user actions such as clicks, so in this case
+        // rather than show the event title (which is always just "Event"), we
+        // add the type ("click") to help the user understand the event.
+        return i18nString(UIStrings.eventDispatchS, { PH1: entry.args.data.type });
+    }
+    if (Types.Events.isSyntheticNetworkRequest(entry)) {
+        const parsedURL = new Common.ParsedURL.ParsedURL(entry.args.data.url);
+        const text = parsedURL.isValid ? `${parsedURL.displayName} (${parsedURL.host})` : entry.args.data.url || 'Network request';
+        return text;
+    }
+    if (Types.Events.isWebSocketCreate(entry)) {
+        if (entry.args.data.url) {
+            return i18nString(UIStrings.wsConnectionOpenedWithUrl, { PH1: entry.args.data.url });
+        }
+        return i18nString(UIStrings.wsConnectionOpened);
+    }
+    if (Types.Events.isWebSocketDestroy(entry)) {
+        return i18nString(UIStrings.wsConnectionClosed);
+    }
+    if (Types.Events.isSyntheticInteraction(entry)) {
+        return nameForInteractionEvent(entry);
+    }
+    if (Types.Events.isSyntheticLayoutShift(entry)) {
+        return i18nString(UIStrings.layoutShift);
+    }
+    if (Types.Events.isSyntheticAnimation(entry) && entry.args.data.beginEvent.args.data.displayName) {
+        return entry.args.data.beginEvent.args.data.displayName;
+    }
+    const eventStyleCustomName = getEventStyle(entry.name)?.title;
+    return eventStyleCustomName || entry.name;
+}
+function nameForInteractionEvent(event) {
+    const category = Handlers.ModelHandlers.UserInteractions.categoryOfInteraction(event);
+    // Because we hide nested interactions, we do not want to show the
+    // specific type of the interaction that was not hidden, so instead we
+    // show just the category of that interaction.
+    if (category === 'OTHER') {
+        return 'Other';
+    }
+    if (category === 'KEYBOARD') {
+        return 'Keyboard';
+    }
+    if (category === 'POINTER') {
+        return 'Pointer';
+    }
+    return event.type;
+}