chrome-devtools-frontend 1.0.1512349 → 1.0.1513662

package/front_end/models/trace/LanternComputationData.ts

@@ -10,9 +10,9 @@ import type * as Types from './types/types.js';
 
 type NetworkRequest = Lantern.Types.NetworkRequest<Types.Events.SyntheticNetworkRequest>;
 
-function createProcessedNavigation(parsedTrace: Handlers.Types.ParsedTrace, frameId: string, navigationId: string):
+function createProcessedNavigation(data: Handlers.Types.HandlerData, frameId: string, navigationId: string):
     Lantern.Types.Simulation.ProcessedNavigation {
-  const scoresByNav = parsedTrace.PageLoadMetrics.metricScoresByFrameId.get(frameId);
+  const scoresByNav = data.PageLoadMetrics.metricScoresByFrameId.get(frameId);
   if (!scoresByNav) {
     throw new Lantern.Core.LanternError('missing metric scores for frame');
   }
@@ -85,7 +85,7 @@ function findWorkerThreads(trace: Lantern.Types.Trace): Map<number, number[]> {
 }
 
 function createLanternRequest(
-    parsedTrace: Readonly<Handlers.Types.ParsedTrace>, workerThreads: Map<number, number[]>,
+    parsedTrace: Readonly<Handlers.Types.HandlerData>, workerThreads: Map<number, number[]>,
     request: Types.Events.SyntheticNetworkRequest): NetworkRequest|undefined {
   if (request.args.data.hasResponse && request.args.data.connectionId === undefined) {
     throw new Lantern.Core.LanternError('Trace is too old');
@@ -273,14 +273,14 @@ function linkInitiators(lanternRequests: NetworkRequest[]): void {
 }
 
 function createNetworkRequests(
-    trace: Lantern.Types.Trace, parsedTrace: Handlers.Types.ParsedTrace, startTime = 0,
+    trace: Lantern.Types.Trace, data: Handlers.Types.HandlerData, startTime = 0,
     endTime = Number.POSITIVE_INFINITY): NetworkRequest[] {
   const workerThreads = findWorkerThreads(trace);
 
   const lanternRequestsNoRedirects: NetworkRequest[] = [];
-  for (const request of parsedTrace.NetworkRequests.byTime) {
+  for (const request of data.NetworkRequests.byTime) {
     if (request.ts >= startTime && request.ts < endTime) {
-      const lanternRequest = createLanternRequest(parsedTrace, workerThreads, request);
+      const lanternRequest = createLanternRequest(data, workerThreads, request);
       if (lanternRequest) {
         lanternRequestsNoRedirects.push(lanternRequest);
       }
@@ -371,8 +371,8 @@ function createNetworkRequests(
 }
 
 function collectMainThreadEvents(
-    trace: Lantern.Types.Trace, parsedTrace: Handlers.Types.ParsedTrace): Lantern.Types.TraceEvent[] {
-  const Meta = parsedTrace.Meta;
+    trace: Lantern.Types.Trace, data: Handlers.Types.HandlerData): Lantern.Types.TraceEvent[] {
+  const Meta = data.Meta;
   const mainFramePids = Meta.mainFrameNavigations.length ? new Set(Meta.mainFrameNavigations.map(nav => nav.pid)) :
                                                            Meta.topLevelRendererIds;
 
@@ -408,9 +408,9 @@ function collectMainThreadEvents(
 }
 
 function createGraph(
-    requests: Lantern.Types.NetworkRequest[], trace: Lantern.Types.Trace, parsedTrace: Handlers.Types.ParsedTrace,
+    requests: Lantern.Types.NetworkRequest[], trace: Lantern.Types.Trace, data: Handlers.Types.HandlerData,
     url?: Lantern.Types.Simulation.URL): Lantern.Graph.Node<Types.Events.SyntheticNetworkRequest> {
-  const mainThreadEvents = collectMainThreadEvents(trace, parsedTrace);
+  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.

package/front_end/models/trace/ModelImpl.ts

@@ -29,7 +29,7 @@ export interface ParseConfig {
  * `createWithSubsetOfHandlers` can be used to run just some handlers.
  **/
 export class Model extends EventTarget {
-  readonly #traces: ParsedTraceFile[] = [];
+  readonly #traces: ParsedTrace[] = [];
   readonly #nextNumberByDomain = new Map<string, number>();
 
   readonly #recordingsAvailable: string[] = [];
@@ -100,14 +100,8 @@ export class Model extends EventTarget {
 
     this.#processor.addEventListener(TraceParseProgressEvent.eventName, onTraceUpdate);
 
-    // Create a parsed trace file.  It will be populated with data from the processor.
-    const file: ParsedTraceFile = {
-      traceEvents,
-      metadata,
-      parsedTrace: null,
-      traceInsights: null,
-      syntheticEventsManager: Helpers.SyntheticEvents.SyntheticEventsManager.createAndActivate(traceEvents),
-    };
+    // 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,
@@ -119,7 +113,11 @@ export class Model extends EventTarget {
         resolveSourceMap: config?.resolveSourceMap,
       };
       await this.#processor.parse(traceEvents, parseConfig);
-      this.#storeParsedFileData(file, this.#processor.parsedTrace, this.#processor.insights);
+      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);
@@ -133,23 +131,27 @@ export class Model extends EventTarget {
     }
   }
 
-  #storeParsedFileData(
-      file: ParsedTraceFile, data: Handlers.Types.ParsedTrace|null,
-      insights: Insights.Types.TraceInsightSets|null): void {
-    file.parsedTrace = data;
-    file.traceInsights = insights;
+  #storeAndCreateParsedTraceFile(
+      syntheticEventsManager: Helpers.SyntheticEvents.SyntheticEventsManager,
+      traceEvents: readonly Types.Events.Event[], metadata: Types.File.MetaData, data: Handlers.Types.HandlerData,
+      traceInsights: Insights.Types.TraceInsightSets|null): ParsedTrace {
     this.#lastRecordingIndex++;
     let recordingName = `Trace ${this.#lastRecordingIndex}`;
-    let origin: string|null = null;
-    if (file.parsedTrace) {
-      origin = Helpers.Trace.extractOriginFromTrace(file.parsedTrace.Meta.mainFrameURL);
-      if (origin) {
-        const nextSequenceForDomain = Platform.MapUtilities.getWithDefault(this.#nextNumberByDomain, origin, () => 1);
-        recordingName = `${origin} (${nextSequenceForDomain})`;
-        this.#nextNumberByDomain.set(origin, nextSequenceForDomain + 1);
-      }
+    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(): number {
@@ -160,16 +162,8 @@ export class Model extends EventTarget {
    * 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: number = this.#traces.length - 1): Handlers.Types.ParsedTrace|null {
-    return this.#traces.at(index)?.parsedTrace ?? null;
-  }
-
-  traceInsights(index: number = this.#traces.length - 1): Insights.Types.TraceInsightSets|null {
-    return this.#traces.at(index)?.traceInsights ?? null;
-  }
-
-  metadata(index: number = this.#traces.length - 1): Types.File.MetaData|null {
-    return this.#traces.at(index)?.metadata ?? null;
+  parsedTrace(index: number = this.#traces.length - 1): ParsedTrace|null {
+    return this.#traces.at(index) ?? null;
   }
 
   overrideModifications(index: number, newModifications: Types.File.Modifications): void {
@@ -178,10 +172,6 @@ export class Model extends EventTarget {
     }
   }
 
-  rawTraceEvents(index: number = this.#traces.length - 1): readonly Types.Events.Event[]|null {
-    return this.#traces.at(index)?.traceEvents ?? null;
-  }
-
   syntheticTraceEventsManager(index: number = this.#traces.length - 1): Helpers.SyntheticEvents.SyntheticEventsManager
       |null {
     return this.#traces.at(index)?.syntheticEventsManager ?? null;
@@ -206,13 +196,14 @@ export class Model extends EventTarget {
 }
 
 /**
- * This parsed trace file is used by the Model. It keeps multiple instances
+ * This parsed trace is used by the Model. It keeps multiple instances
  * of these so that the user can swap between them. The key is that it is
  * essentially the TraceFile plus whatever the model has parsed from it.
  */
-export type ParsedTraceFile = Types.File.TraceFile&{
-  parsedTrace: Handlers.Types.ParsedTrace | null,
-  traceInsights: Insights.Types.TraceInsightSets | null,
+export type ParsedTrace = Types.File.TraceFile&{
+  data: Handlers.Types.HandlerData,
+  /** Is null for CPU profiles. */
+  insights: Insights.Types.TraceInsightSets | null,
   syntheticEventsManager: Helpers.SyntheticEvents.SyntheticEventsManager,
 };
 

package/front_end/models/trace/Processor.ts

@@ -56,7 +56,7 @@ export class TraceProcessor extends EventTarget {
   readonly #traceHandlers: Partial<Handlers.Types.Handlers>;
   #status = Status.IDLE;
   #modelConfiguration = Types.Configuration.defaults();
-  #data: Handlers.Types.ParsedTrace|null = null;
+  #data: Handlers.Types.HandlerData|null = null;
   #insights: Insights.Types.TraceInsightSets|null = null;
 
   static createWithAllHandlers(): TraceProcessor {
@@ -243,10 +243,10 @@ export class TraceProcessor extends EventTarget {
 
     this.dispatchEvent(new TraceParseProgressEvent({percent: ProgressPhase.CLONE}));
 
-    this.#data = parsedTrace as Handlers.Types.ParsedTrace;
+    this.#data = parsedTrace as Handlers.Types.HandlerData;
   }
 
-  get parsedTrace(): Handlers.Types.ParsedTrace|null {
+  get data(): Handlers.Types.HandlerData|null {
     if (this.#status !== Status.FINISHED_PARSING) {
       return null;
     }
@@ -263,17 +263,17 @@ export class TraceProcessor extends EventTarget {
   }
 
   #createLanternContext(
-      parsedTrace: Handlers.Types.ParsedTrace, traceEvents: readonly Types.Events.Event[], frameId: string,
+      data: Handlers.Types.HandlerData, traceEvents: readonly Types.Events.Event[], frameId: string,
       navigationId: string, options: Types.Configuration.ParseOptions): Insights.Types.LanternContext|undefined {
     // Check for required handlers.
-    if (!parsedTrace.NetworkRequests || !parsedTrace.Workers || !parsedTrace.PageLoadMetrics) {
+    if (!data.NetworkRequests || !data.Workers || !data.PageLoadMetrics) {
       return;
     }
-    if (!parsedTrace.NetworkRequests.byTime.length) {
+    if (!data.NetworkRequests.byTime.length) {
       throw new Lantern.Core.LanternError('No network requests found in trace');
     }
 
-    const navStarts = parsedTrace.Meta.navigationsByFrameId.get(frameId);
+    const navStarts = data.Meta.navigationsByFrameId.get(frameId);
     const navStartIndex = navStarts?.findIndex(n => n.args.data?.navigationId === navigationId);
     if (!navStarts || navStartIndex === undefined || navStartIndex === -1) {
       throw new Lantern.Core.LanternError('Could not find navigation start');
@@ -289,9 +289,9 @@ export class TraceProcessor extends EventTarget {
       traceEvents: boundedTraceEvents as unknown as Lantern.Types.TraceEvent[],
     };
 
-    const requests = LanternComputationData.createNetworkRequests(trace, parsedTrace, startTime, endTime);
-    const graph = LanternComputationData.createGraph(requests, trace, parsedTrace);
-    const processedNavigation = LanternComputationData.createProcessedNavigation(parsedTrace, frameId, navigationId);
+    const requests = LanternComputationData.createNetworkRequests(trace, data, startTime, endTime);
+    const graph = LanternComputationData.createGraph(requests, trace, data);
+    const processedNavigation = LanternComputationData.createProcessedNavigation(data, frameId, navigationId);
 
     const networkAnalysis = Lantern.Core.NetworkAnalyzer.analyze(requests);
     if (!networkAnalysis) {
@@ -425,17 +425,16 @@ export class TraceProcessor extends EventTarget {
   }
 
   #computeInsightSet(
-      parsedTrace: Handlers.Types.ParsedTrace, context: Insights.Types.InsightSetContext,
+      data: Handlers.Types.HandlerData, context: Insights.Types.InsightSetContext,
       options: Types.Configuration.ParseOptions): void {
     let id, urlString, navigation;
     if (context.navigation) {
       id = context.navigationId;
-      urlString =
-          parsedTrace.Meta.finalDisplayUrlByNavigationId.get(context.navigationId) ?? parsedTrace.Meta.mainFrameURL;
+      urlString = data.Meta.finalDisplayUrlByNavigationId.get(context.navigationId) ?? data.Meta.mainFrameURL;
       navigation = context.navigation;
     } else {
       id = Types.Events.NO_NAVIGATION;
-      urlString = parsedTrace.Meta.finalDisplayUrlByNavigationId.get('') ?? parsedTrace.Meta.mainFrameURL;
+      urlString = data.Meta.finalDisplayUrlByNavigationId.get('') ?? data.Meta.mainFrameURL;
     }
 
     const insightSetModel = {} as Insights.Types.InsightSet['model'];
@@ -444,7 +443,7 @@ export class TraceProcessor extends EventTarget {
       let model: Insights.Types.InsightModel|Error;
       try {
         options.logger?.start(`insights:${name}`);
-        model = insight.generateInsight(parsedTrace, context);
+        model = insight.generateInsight(data, context);
         model.frameId = context.frameId;
         const navId = context.navigation?.args.data?.navigationId;
         if (navId) {
@@ -511,24 +510,24 @@ export class TraceProcessor extends EventTarget {
    * Run all the insights and set the result to `#insights`.
    */
   #computeInsights(
-      parsedTrace: Handlers.Types.ParsedTrace, traceEvents: readonly Types.Events.Event[],
+      data: Handlers.Types.HandlerData, traceEvents: readonly Types.Events.Event[],
       options: Types.Configuration.ParseOptions): void {
     // This insights map will be populated by the helper methods.
     this.#insights = new Map();
 
     // Filter main frame navigations to those that have the necessary data (frameId and navigationId).
     // TODO(cjamcl): Does this filtering makes the "use the next nav as the end time" logic potentially broken? Are navs without nav id or frame even real?
-    const navigations = parsedTrace.Meta.mainFrameNavigations.filter(
+    const navigations = data.Meta.mainFrameNavigations.filter(
         navigation => navigation.args.frame && navigation.args.data?.navigationId);
 
-    this.#computeInsightsForInitialTracePeriod(parsedTrace, navigations, options);
+    this.#computeInsightsForInitialTracePeriod(data, navigations, options);
 
     for (const [index, navigation] of navigations.entries()) {
       const min = navigation.ts;
       // Use trace end for the last navigation, otherwise use the start of the next navigation.
-      const max = index + 1 < navigations.length ? navigations[index + 1].ts : parsedTrace.Meta.traceBounds.max;
+      const max = index + 1 < navigations.length ? navigations[index + 1].ts : data.Meta.traceBounds.max;
       const bounds = Helpers.Timing.traceWindowFromMicroSeconds(min, max);
-      this.#computeInsightsForNavigation(navigation, bounds, parsedTrace, traceEvents, options);
+      this.#computeInsightsForNavigation(navigation, bounds, data, traceEvents, options);
     }
   }
 
@@ -536,28 +535,27 @@ export class TraceProcessor extends EventTarget {
    * Computes insights for the period before the first navigation, or for the entire trace if no navigations exist.
    */
   #computeInsightsForInitialTracePeriod(
-      parsedTrace: Handlers.Types.ParsedTrace, navigations: readonly Types.Events.NavigationStart[],
+      data: Handlers.Types.HandlerData, navigations: readonly Types.Events.NavigationStart[],
       options: Types.Configuration.ParseOptions): void {
     // Determine bounds: Use the period before the first navigation if navigations exist, otherwise use the entire trace bounds.
     const bounds = navigations.length > 0 ?
-        Helpers.Timing.traceWindowFromMicroSeconds(parsedTrace.Meta.traceBounds.min, navigations[0].ts) :
-        parsedTrace.Meta.traceBounds;
+        Helpers.Timing.traceWindowFromMicroSeconds(data.Meta.traceBounds.min, navigations[0].ts) :
+        data.Meta.traceBounds;
 
     const context: Insights.Types.InsightSetContext = {
       bounds,
-      frameId: parsedTrace.Meta.mainFrameId,
+      frameId: data.Meta.mainFrameId,
       // No navigation or lantern context applies to this initial/no-navigation period.
     };
-    this.#computeInsightSet(parsedTrace, context, options);
+    this.#computeInsightSet(data, context, options);
   }
 
   /**
    * Computes insights for a specific navigation event.
    */
   #computeInsightsForNavigation(
-      navigation: Types.Events.NavigationStart, bounds: Types.Timing.TraceWindowMicro,
-      parsedTrace: Handlers.Types.ParsedTrace, traceEvents: readonly Types.Events.Event[],
-      options: Types.Configuration.ParseOptions): void {
+      navigation: Types.Events.NavigationStart, bounds: Types.Timing.TraceWindowMicro, data: Handlers.Types.HandlerData,
+      traceEvents: readonly Types.Events.Event[], options: Types.Configuration.ParseOptions): void {
     const frameId = navigation.args.frame;
     // Guaranteed by the filter in #computeInsights
     const navigationId = navigation.args.data?.navigationId as string;
@@ -568,7 +566,7 @@ export class TraceProcessor extends EventTarget {
     let lantern: Insights.Types.LanternContext|undefined;
     try {
       options.logger?.start('insights:createLanternContext');
-      lantern = this.#createLanternContext(parsedTrace, traceEvents, frameId, navigationId, options);
+      lantern = this.#createLanternContext(data, traceEvents, frameId, navigationId, options);
     } catch (e) {
       // Handle Lantern errors gracefully
       // Don't allow an error in constructing the Lantern graphs to break the rest of the trace processor.
@@ -601,7 +599,7 @@ export class TraceProcessor extends EventTarget {
       navigationId,
       lantern,
     };
-    this.#computeInsightSet(parsedTrace, context, options);
+    this.#computeInsightSet(data, context, options);
   }
 }
 

package/front_end/models/trace/extras/FilmStrip.ts

@@ -32,17 +32,17 @@ export type HandlerDataWithScreenshots = Handlers.Types.EnabledHandlerDataWithMe
 // 2. The start time.
 const filmStripCache = new WeakMap<HandlerDataWithScreenshots, Map<Types.Timing.Micro, Data>>();
 
-export function fromParsedTrace(parsedTrace: HandlerDataWithScreenshots, customZeroTime?: Types.Timing.Micro): Data {
+export function fromHandlerData(data: HandlerDataWithScreenshots, customZeroTime?: Types.Timing.Micro): Data {
   const frames: Frame[] = [];
 
-  const zeroTime = typeof customZeroTime !== 'undefined' ? customZeroTime : parsedTrace.Meta.traceBounds.min;
-  const spanTime = parsedTrace.Meta.traceBounds.range;
-  const fromCache = filmStripCache.get(parsedTrace)?.get(zeroTime);
+  const zeroTime = typeof customZeroTime !== 'undefined' ? customZeroTime : data.Meta.traceBounds.min;
+  const spanTime = data.Meta.traceBounds.range;
+  const fromCache = filmStripCache.get(data)?.get(zeroTime);
   if (fromCache) {
     return fromCache;
   }
 
-  const screenshots = parsedTrace.Screenshots.screenshots ?? parsedTrace.Screenshots.legacySyntheticScreenshots ?? [];
+  const screenshots = data.Screenshots.screenshots ?? data.Screenshots.legacySyntheticScreenshots ?? [];
 
   for (const screenshotEvent of screenshots) {
     if (screenshotEvent.ts < zeroTime) {
@@ -62,7 +62,7 @@ export function fromParsedTrace(parsedTrace: HandlerDataWithScreenshots, customZ
   };
 
   const cachedForData =
-      Platform.MapUtilities.getWithDefault(filmStripCache, parsedTrace, () => new Map<Types.Timing.Micro, Data>());
+      Platform.MapUtilities.getWithDefault(filmStripCache, data, () => new Map<Types.Timing.Micro, Data>());
   cachedForData.set(zeroTime, result);
 
   return result;

package/front_end/models/trace/extras/StackTraceForEvent.ts

@@ -8,10 +8,10 @@ import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
 export const stackTraceForEventInTrace =
-    new Map<Handlers.Types.ParsedTrace, Map<Types.Events.Event, Protocol.Runtime.StackTrace>>();
+    new Map<Handlers.Types.HandlerData, Map<Types.Events.Event, Protocol.Runtime.StackTrace>>();
 
-export function clearCacheForTrace(parsedTrace: Handlers.Types.ParsedTrace): void {
-  stackTraceForEventInTrace.delete(parsedTrace);
+export function clearCacheForTrace(data: Handlers.Types.HandlerData): void {
+  stackTraceForEventInTrace.delete(data);
 }
 /**
  * This util builds a stack trace that includes async calls for a given
@@ -19,12 +19,11 @@ export function clearCacheForTrace(parsedTrace: Handlers.Types.ParsedTrace): voi
  * stacks and trace event instrumentation on the V8 debugger to stitch
  * them together.
  */
-export function get(event: Types.Events.Event, parsedTrace: Handlers.Types.ParsedTrace): Protocol.Runtime.StackTrace|
-    null {
-  let cacheForTrace = stackTraceForEventInTrace.get(parsedTrace);
+export function get(event: Types.Events.Event, data: Handlers.Types.HandlerData): Protocol.Runtime.StackTrace|null {
+  let cacheForTrace = stackTraceForEventInTrace.get(data);
   if (!cacheForTrace) {
     cacheForTrace = new Map();
-    stackTraceForEventInTrace.set(parsedTrace, cacheForTrace);
+    stackTraceForEventInTrace.set(data, cacheForTrace);
   }
   const resultFromCache = cacheForTrace.get(event);
   if (resultFromCache) {
@@ -32,11 +31,11 @@ export function get(event: Types.Events.Event, parsedTrace: Handlers.Types.Parse
   }
   let result: Protocol.Runtime.StackTrace|null = null;
   if (Types.Extensions.isSyntheticExtensionEntry(event)) {
-    result = getForExtensionEntry(event, parsedTrace);
+    result = getForExtensionEntry(event, data);
   } else if (Types.Events.isPerformanceMeasureBegin(event)) {
-    result = getForPerformanceMeasure(event, parsedTrace);
+    result = getForPerformanceMeasure(event, data);
   } else {
-    result = getForEvent(event, parsedTrace);
+    result = getForEvent(event, data);
     const payloadCallFrames =
         getTraceEventPayloadStackAsProtocolCallFrame(event).filter(callFrame => !isNativeJSFunction(callFrame));
     // If the event has a payload stack trace, replace the synchronous
@@ -65,24 +64,22 @@ export function get(event: Types.Events.Event, parsedTrace: Handlers.Types.Parse
  * hierarchy. This shouldn't be called outside of this file, use `get`
  * instead to ensure the correct event in the tree hierarchy is used.
  */
-function getForEvent(event: Types.Events.Event, parsedTrace: Handlers.Types.ParsedTrace): Protocol.Runtime.StackTrace {
+function getForEvent(event: Types.Events.Event, data: Handlers.Types.HandlerData): Protocol.Runtime.StackTrace {
   // When working with a CPU profile the renderer handler won't have
   // entries in its tree.
-  const entryToNode =
-      parsedTrace.Renderer.entryToNode.size > 0 ? parsedTrace.Renderer.entryToNode : parsedTrace.Samples.entryToNode;
+  const entryToNode = data.Renderer.entryToNode.size > 0 ? data.Renderer.entryToNode : data.Samples.entryToNode;
   const topStackTrace: Protocol.Runtime.StackTrace = {callFrames: []};
   let stackTrace: Protocol.Runtime.StackTrace = topStackTrace;
   let currentEntry: Types.Events.SyntheticProfileCall;
   let node: Helpers.TreeHelpers.TraceEntryNode|null|undefined = entryToNode.get(event);
-  const traceCache =
-      stackTraceForEventInTrace.get(parsedTrace) || new Map<Types.Events.Event, Protocol.Runtime.StackTrace>();
-  stackTraceForEventInTrace.set(parsedTrace, traceCache);
+  const traceCache = stackTraceForEventInTrace.get(data) || new Map<Types.Events.Event, Protocol.Runtime.StackTrace>();
+  stackTraceForEventInTrace.set(data, traceCache);
   // Move up this node's ancestor tree appending JS frames to its
   // stack trace. If an async caller is detected, move up in the async
   // stack instead.
   while (node) {
     if (!Types.Events.isProfileCall(node.entry)) {
-      const maybeAsyncParent = parsedTrace.AsyncJSCalls.runEntryPointToScheduler.get(node.entry);
+      const maybeAsyncParent = data.AsyncJSCalls.runEntryPointToScheduler.get(node.entry);
       if (!maybeAsyncParent) {
         node = node.parent;
         continue;
@@ -114,7 +111,7 @@ function getForEvent(event: Types.Events.Event, parsedTrace: Handlers.Types.Pars
     if (!isNativeJSFunction(currentEntry.callFrame)) {
       stackTrace.callFrames.push(currentEntry.callFrame);
     }
-    const maybeAsyncParentEvent = parsedTrace.AsyncJSCalls.asyncCallToScheduler.get(currentEntry);
+    const maybeAsyncParentEvent = data.AsyncJSCalls.asyncCallToScheduler.get(currentEntry);
     const maybeAsyncParentNode = maybeAsyncParentEvent && entryToNode.get(maybeAsyncParentEvent.scheduler);
     if (maybeAsyncParentNode) {
       stackTrace = addAsyncParentToStack(stackTrace, maybeAsyncParentEvent.taskName);
@@ -147,23 +144,23 @@ function addAsyncParentToStack(stackTrace: Protocol.Runtime.StackTrace, taskName
  * code location that called the extension API), and returns its stack
  * trace.
  */
-function getForExtensionEntry(event: Types.Extensions.SyntheticExtensionEntry, parsedTrace: Handlers.Types.ParsedTrace):
+function getForExtensionEntry(event: Types.Extensions.SyntheticExtensionEntry, data: Handlers.Types.HandlerData):
     Protocol.Runtime.StackTrace|null {
   const rawEvent: Types.Events.Event = event.rawSourceEvent;
   if (Types.Events.isPerformanceMeasureBegin(rawEvent)) {
-    return getForPerformanceMeasure(rawEvent, parsedTrace);
+    return getForPerformanceMeasure(rawEvent, data);
   }
   if (!rawEvent) {
     return null;
   }
-  return get(rawEvent, parsedTrace);
+  return get(rawEvent, data);
 }
 
 /**
  * Gets the raw event for a user timing and obtains its stack trace.
  */
-function getForPerformanceMeasure(event: Types.Events.PerformanceMeasureBegin, parsedTrace: Handlers.Types.ParsedTrace):
-    Protocol.Runtime.StackTrace|null {
+function getForPerformanceMeasure(
+    event: Types.Events.PerformanceMeasureBegin, data: Handlers.Types.HandlerData): Protocol.Runtime.StackTrace|null {
   let rawEvent: Types.Events.Event|undefined = event;
   if (event.args.traceId === undefined) {
     return null;
@@ -173,11 +170,11 @@ function getForPerformanceMeasure(event: Types.Events.PerformanceMeasureBegin, p
   // timeline. They are connected via a common traceId. At this
   // point `rawEvent` corresponds to the second case, we must
   // encounter the event for the call itself to obtain its callstack.
-  rawEvent = parsedTrace.UserTimings.measureTraceByTraceId.get(event.args.traceId);
+  rawEvent = data.UserTimings.measureTraceByTraceId.get(event.args.traceId);
   if (!rawEvent) {
     return null;
   }
-  return get(rawEvent, parsedTrace);
+  return get(rawEvent, data);
 }
 /**
  * Determines if a function is a native JS API (like setTimeout,

package/front_end/models/trace/extras/ThirdParties.ts

@@ -32,9 +32,9 @@ export interface URLSummary extends BaseSummary {
  * Returns Main frame main thread events.
  * These events are inline with the ones used by selectedEvents() of TimelineTreeViews
  */
-function collectMainThreadActivity(parsedTrace: Handlers.Types.ParsedTrace): Types.Events.Event[] {
+function collectMainThreadActivity(data: Handlers.Types.HandlerData): Types.Events.Event[] {
   // TODO: Note b/402658800 could be an issue here.
-  const mainFrameMainThread = parsedTrace.Renderer.processes.values()
+  const mainFrameMainThread = data.Renderer.processes.values()
                                   .find(p => {
                                     const url = p.url ?? '';
                                     // Frame url checked a la CompatibilityTracksAppenders's addThreadAppenders
@@ -51,14 +51,14 @@ function collectMainThreadActivity(parsedTrace: Handlers.Types.ParsedTrace): Typ
 }
 
 export function summarizeByThirdParty(
-    parsedTrace: Handlers.Types.ParsedTrace, traceBounds: Types.Timing.TraceWindowMicro): EntitySummary[] {
-  const mainThreadEvents = collectMainThreadActivity(parsedTrace).sort(Helpers.Trace.eventTimeComparator);
+    data: Handlers.Types.HandlerData, traceBounds: Types.Timing.TraceWindowMicro): EntitySummary[] {
+  const mainThreadEvents = collectMainThreadActivity(data).sort(Helpers.Trace.eventTimeComparator);
   const groupingFunction = (event: Types.Events.Event): string => {
-    const entity = parsedTrace.Renderer.entityMappings.entityByEvent.get(event);
+    const entity = data.Renderer.entityMappings.entityByEvent.get(event);
     return entity?.name ?? '';
   };
   const node = getBottomUpTree(mainThreadEvents, traceBounds, groupingFunction);
-  const summaries = summarizeBottomUpByEntity(node, parsedTrace);
+  const summaries = summarizeBottomUpByEntity(node, data);
 
   return summaries;
 }
@@ -67,19 +67,19 @@ export function summarizeByThirdParty(
  * Used only by Lighthouse.
  */
 export function summarizeByURL(
-    parsedTrace: Handlers.Types.ParsedTrace, traceBounds: Types.Timing.TraceWindowMicro): URLSummary[] {
-  const mainThreadEvents = collectMainThreadActivity(parsedTrace).sort(Helpers.Trace.eventTimeComparator);
+    data: Handlers.Types.HandlerData, traceBounds: Types.Timing.TraceWindowMicro): URLSummary[] {
+  const mainThreadEvents = collectMainThreadActivity(data).sort(Helpers.Trace.eventTimeComparator);
   const groupingFunction = (event: Types.Events.Event): string => {
-    return Handlers.Helpers.getNonResolvedURL(event, parsedTrace) ?? '';
+    return Handlers.Helpers.getNonResolvedURL(event, data) ?? '';
   };
   const node = getBottomUpTree(mainThreadEvents, traceBounds, groupingFunction);
-  const summaries = summarizeBottomUpByURL(node, parsedTrace);
+  const summaries = summarizeBottomUpByURL(node, data);
 
   return summaries;
 }
 
 function summarizeBottomUpByEntity(
-    root: TraceTree.BottomUpRootNode, parsedTrace: Handlers.Types.ParsedTrace): EntitySummary[] {
+    root: TraceTree.BottomUpRootNode, data: Handlers.Types.HandlerData): EntitySummary[] {
   const summaries: EntitySummary[] = [];
 
   // Top nodes are the 3P entities.
@@ -89,7 +89,7 @@ function summarizeBottomUpByEntity(
       continue;
     }
 
-    const entity = parsedTrace.Renderer.entityMappings.entityByEvent.get(node.event);
+    const entity = data.Renderer.entityMappings.entityByEvent.get(node.event);
     if (!entity) {
       continue;
     }
@@ -100,7 +100,7 @@ function summarizeBottomUpByEntity(
       transferSize: node.transferSize,
       mainThreadTime: Types.Timing.Milli(node.selfTime),
       entity,
-      relatedEvents: parsedTrace.Renderer.entityMappings.eventsByEntity.get(entity) ?? [],
+      relatedEvents: data.Renderer.entityMappings.eventsByEntity.get(entity) ?? [],
     };
     summaries.push(summary);
   }
@@ -108,10 +108,9 @@ function summarizeBottomUpByEntity(
   return summaries;
 }
 
-function summarizeBottomUpByURL(
-    root: TraceTree.BottomUpRootNode, parsedTrace: Handlers.Types.ParsedTrace): URLSummary[] {
+function summarizeBottomUpByURL(root: TraceTree.BottomUpRootNode, data: Handlers.Types.HandlerData): URLSummary[] {
   const summaries: URLSummary[] = [];
-  const allRequests = parsedTrace.NetworkRequests.byTime;
+  const allRequests = data.NetworkRequests.byTime;
 
   // Top nodes are URLs.
   const topNodes = [...root.children().values()].flat();
@@ -120,7 +119,7 @@ function summarizeBottomUpByURL(
       continue;
     }
 
-    const entity = parsedTrace.Renderer.entityMappings.entityByEvent.get(node.event);
+    const entity = data.Renderer.entityMappings.entityByEvent.get(node.event);
     if (!entity) {
       continue;
     }

package/front_end/models/trace/extras/TraceFilter.ts

@@ -6,7 +6,7 @@ import type * as Handlers from '../handlers/handlers.js';
 import * as Types from '../types/types.js';
 
 export abstract class TraceFilter {
-  abstract accept(_event: Types.Events.Event, parsedTrace?: Handlers.Types.ParsedTrace): boolean;
+  abstract accept(_event: Types.Events.Event, handlerData?: Handlers.Types.HandlerData): boolean;
 }
 
 export class VisibleEventsFilter extends TraceFilter {