devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/models/trace/LanternComputationData.ts

@@ -1,438 +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 Protocol from '../../generated/protocol.js';
-
-import * as Handlers from './handlers/handlers.js';
-import * as Lantern from './lantern/lantern.js';
-import type * as Types from './types/types.js';
-
-type NetworkRequest = Lantern.Types.NetworkRequest<Types.Events.SyntheticNetworkRequest>;
-
-function createProcessedNavigation(data: Handlers.Types.HandlerData, frameId: string, navigationId: string):
-    Lantern.Types.Simulation.ProcessedNavigation {
-  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: Handlers.ModelHandlers.PageLoadMetrics.MetricName): Types.Timing.Micro|undefined => {
-        const metricScore = scores.get(metric);
-        if (!metricScore?.event) {
-          return;
-        }
-        return metricScore.event.ts;
-      };
-  const getTimestamp = (metric: Handlers.ModelHandlers.PageLoadMetrics.MetricName): Types.Timing.Micro => {
-    const metricScore = scores.get(metric);
-    if (!metricScore?.event) {
-      throw new Lantern.Core.LanternError(`missing metric: ${metric}`);
-    }
-    return metricScore.event.ts;
-  };
-  return {
-    timestamps: {
-      firstContentfulPaint: getTimestamp(Handlers.ModelHandlers.PageLoadMetrics.MetricName.FCP),
-      largestContentfulPaint: getTimestampOrUndefined(Handlers.ModelHandlers.PageLoadMetrics.MetricName.LCP),
-    },
-  };
-}
-
-function createParsedUrl(url: URL|string): Lantern.Types.ParsedURL {
-  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: Lantern.Types.Trace): Map<number, number[]> {
-  // 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: 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');
-  }
-
-  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: Lantern.Types.NetworkRequest['initiator'] =
-      request.args.data.initiator ?? {type: Protocol.Network.InitiatorType.Other};
-  if (request.args.data.stackTrace) {
-    const callFrames = request.args.data.stackTrace.map(f => {
-      return {
-        scriptId: String(f.scriptId) as Protocol.Runtime.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,
-    serverResponseTime: request.args.data.lrServerResponseTime ?? undefined,
-    // Set later.
-    redirects: undefined,
-    redirectSource: undefined,
-    redirectDestination: undefined,
-    initiatorRequest: undefined,
-  };
-}
-
-/**
- * @param request The request to find the initiator of
- */
-function chooseInitiatorRequest(request: NetworkRequest, requestsByURL: Map<string, NetworkRequest[]>): NetworkRequest|
-    null {
-  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: NetworkRequest[]): void {
-  const requestsByURL = new Map<string, NetworkRequest[]>();
-  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: 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 data.NetworkRequests.byTime) {
-    if (request.ts >= startTime && request.ts < endTime) {
-      const lanternRequest = createLanternRequest(data, workerThreads, request);
-      if (lanternRequest) {
-        lanternRequestsNoRedirects.push(lanternRequest);
-      }
-    }
-  }
-
-  const lanternRequests: NetworkRequest[] = [];
-
-  // 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: 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;
-
-  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: 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, 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/lib/front_end/models/trace/ModelImpl.ts

@@ -1,236 +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 Platform from '../../core/platform/platform.js';
-
-import * as Handlers from './handlers/handlers.js';
-import * as Helpers from './helpers/helpers.js';
-import type * as Insights from './insights/insights.js';
-import {TraceParseProgressEvent, TraceProcessor} from './Processor.js';
-import * as Types from './types/types.js';
-
-// Note: this model is implemented in a way that can support multiple trace
-// processors. Currently there is only one implemented, but you will see
-// references to "processors" plural because it can easily be extended in the future.
-
-/**
- * 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 {
-  readonly #traces: ParsedTrace[] = [];
-  readonly #nextNumberByDomain = new Map<string, number>();
-
-  readonly #recordingsAvailable: string[] = [];
-  #lastRecordingIndex = 0;
-  #processor: TraceProcessor;
-  #config: Types.Configuration.Configuration = Types.Configuration.defaults();
-
-  static createWithAllHandlers(config?: Types.Configuration.Configuration): Model {
-    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: Partial<Handlers.Types.Handlers>, config?: Types.Configuration.Configuration): Model {
-    return new Model(traceHandlers as Handlers.Types.Handlers, config);
-  }
-
-  constructor(handlers: Handlers.Types.Handlers, config?: Types.Configuration.Configuration) {
-    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: readonly Types.Events.Event[], config: Types.Configuration.ParseOptions = {}):
-      Promise<void> {
-    if (config.showAllEvents === undefined) {
-      config.showAllEvents = this.#config.showAllEvents;
-    }
-
-    const metadata = config.metadata || {};
-    // During parsing, periodically update any listeners on each processors'
-    // progress (if they have any updates).
-    const onTraceUpdate = (event: Event): void => {
-      const {data} = event as TraceParseProgressEvent;
-      this.dispatchEvent(new ModelUpdateEvent({type: 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.
-      await this.#processor.parse(traceEvents, config);
-      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: ModelUpdateType.COMPLETE, data: 'done'}));
-    }
-  }
-
-  #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}`;
-    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 {
-    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: number = this.#traces.length - 1): ParsedTrace|null {
-    return this.#traces.at(index) ?? null;
-  }
-
-  overrideModifications(index: number, newModifications: Types.File.Modifications): void {
-    if (this.#traces[index]) {
-      this.#traces[index].metadata.modifications = newModifications;
-    }
-  }
-
-  syntheticTraceEventsManager(index: number = this.#traces.length - 1): Helpers.SyntheticEvents.SyntheticEventsManager
-      |null {
-    return this.#traces.at(index)?.syntheticEventsManager ?? null;
-  }
-
-  size(): number {
-    return this.#traces.length;
-  }
-
-  deleteTraceByIndex(recordingIndex: number): void {
-    this.#traces.splice(recordingIndex, 1);
-    this.#recordingsAvailable.splice(recordingIndex, 1);
-  }
-
-  getRecordingsAvailable(): string[] {
-    return this.#recordingsAvailable;
-  }
-
-  resetProcessor(): void {
-    this.#processor.reset();
-  }
-}
-
-/**
- * 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 ParsedTrace = Types.File.TraceFile&{
-  data: Handlers.Types.HandlerData,
-  /** Is null for CPU profiles. */
-  insights: Insights.Types.TraceInsightSets | null,
-  syntheticEventsManager: Helpers.SyntheticEvents.SyntheticEventsManager,
-};
-
-export const enum ModelUpdateType {
-  COMPLETE = 'COMPLETE',
-  PROGRESS_UPDATE = 'PROGRESS_UPDATE',
-}
-
-export type ModelUpdateEventData = ModelUpdateEventComplete|ModelUpdateEventProgress;
-
-export interface ModelUpdateEventComplete {
-  type: ModelUpdateType.COMPLETE;
-  data: 'done';
-}
-export interface ModelUpdateEventProgress {
-  type: ModelUpdateType.PROGRESS_UPDATE;
-  data: TraceParseEventProgressData;
-}
-
-export interface TraceParseEventProgressData {
-  percent: number;
-}
-
-export class ModelUpdateEvent extends Event {
-  static readonly eventName = 'modelupdate';
-  constructor(public data: ModelUpdateEventData) {
-    super(ModelUpdateEvent.eventName);
-  }
-}
-
-declare global {
-  interface HTMLElementEventMap {
-    [ModelUpdateEvent.eventName]: ModelUpdateEvent;
-  }
-}
-
-export function isModelUpdateDataComplete(eventData: ModelUpdateEventData): eventData is ModelUpdateEventComplete {
-  return eventData.type === ModelUpdateType.COMPLETE;
-}