chrome-devtools-frontend 1.0.1376716 → 1.0.1386602

package/front_end/models/{timeline_model/TimelineProfileTree.ts → trace/extras/TraceTree.ts}

@@ -2,27 +2,34 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Protocol from '../../generated/protocol.js';
-import * as Trace from '../../models/trace/trace.js';
+import type * as Protocol from '../../../generated/protocol.js';
+import * as Helpers from '../helpers/helpers.js';
+import * as Types from '../types/types.js';
 
 import {TimelineJSProfileProcessor} from './TimelineJSProfile.js';
-import type {TimelineModelFilter} from './TimelineModelFilter.js';
+import type {TraceFilter} from './TraceFilter.js';
 
 export class Node {
   totalTime: number;
   selfTime: number;
   id: string|symbol;
-  event: Trace.Types.Events.Event|null;
+  /** The first trace event encountered that necessitated the creation of this tree node. */
+  event: Types.Events.Event;
+  /** All of the trace events associated with this aggregate node.
+   * Minor: In the case of Event Log (EventsTimelineTreeView), the node is not aggregate and this will only hold 1 event, the same that's in this.event
+   */
+  events: Types.Events.Event[];
   parent!: Node|null;
   groupId: string;
   isGroupNodeInternal: boolean;
   depth: number;
 
-  constructor(id: string|symbol, event: Trace.Types.Events.Event|null) {
+  constructor(id: string|symbol, event: Types.Events.Event) {
     this.totalTime = 0;
     this.selfTime = 0;
     this.id = id;
     this.event = event;
+    this.events = [event];
 
     this.groupId = '';
     this.isGroupNodeInternal = false;
@@ -48,7 +55,7 @@ export class Node {
     throw 'Not implemented';
   }
 
-  searchTree(matchFunction: (arg0: Trace.Types.Events.Event) => boolean, results?: Node[]): Node[] {
+  searchTree(matchFunction: (arg0: Types.Events.Event) => boolean, results?: Node[]): Node[] {
     results = results || [];
     if (this.event && matchFunction(this.event)) {
       results.push(this);
@@ -66,7 +73,7 @@ export class TopDownNode extends Node {
   childrenInternal: ChildrenCache|null;
   override parent: TopDownNode|null;
 
-  constructor(id: string|symbol, event: Trace.Types.Events.Event|null, parent: TopDownNode|null) {
+  constructor(id: string|symbol, event: Types.Events.Event, parent: TopDownNode|null) {
     super(id, event);
     this.root = parent && parent.root;
     this.hasChildrenInternal = false;
@@ -102,7 +109,7 @@ export class TopDownNode extends Node {
     }
     const startTime = root.startTime;
     const endTime = root.endTime;
-    const instantEventCallback = root.doNotAggregate ? onInstantEvent : undefined;
+    const instantEventCallback = (root.doNotAggregate || root.includeInstantEvents) ? onInstantEvent : undefined;
     const eventIdCallback = root.doNotAggregate ? undefined : generateEventID;
     const eventGroupIdCallback = root.getEventGroupIdCallback();
     let depth = 0;
@@ -112,21 +119,21 @@ export class TopDownNode extends Node {
     let currentDirectChild: Node|null = null;
 
     // Walk on the full event tree to find this node's children.
-    Trace.Helpers.Trace.forEachEvent(
+    Helpers.Trace.forEachEvent(
         root.events,
         {
           onStartEvent,
           onEndEvent,
           onInstantEvent: instantEventCallback,
-          startTime: Trace.Helpers.Timing.millisecondsToMicroseconds(startTime),
-          endTime: Trace.Helpers.Timing.millisecondsToMicroseconds(endTime),
+          startTime: Helpers.Timing.millisecondsToMicroseconds(startTime),
+          endTime: Helpers.Timing.millisecondsToMicroseconds(endTime),
           eventFilter: root.filter,
           ignoreAsyncEvents: false,
         },
     );
 
-    function onStartEvent(e: Trace.Types.Events.Event): void {
-      const {startTime: currentStartTime, endTime: currentEndTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(e);
+    function onStartEvent(e: Types.Events.Event): void {
+      const {startTime: currentStartTime, endTime: currentEndTime} = Helpers.Timing.eventTimingsMilliSeconds(e);
 
       ++depth;
       if (depth > path.length + 2) {
@@ -143,7 +150,7 @@ export class TopDownNode extends Node {
       processEvent(e, duration);
     }
 
-    function onInstantEvent(e: Trace.Types.Events.Event): void {
+    function onInstantEvent(e: Types.Events.Event): void {
       ++depth;
       if (matchedDepth === path.length && depth <= path.length + 2) {
         processEvent(e, 0);
@@ -154,7 +161,7 @@ export class TopDownNode extends Node {
     /**
      * Creates a child node.
      */
-    function processEvent(e: Trace.Types.Events.Event, duration: number): void {
+    function processEvent(e: Types.Events.Event, duration: number): void {
       if (depth === path.length + 2) {
         if (!currentDirectChild) {
           return;
@@ -179,6 +186,8 @@ export class TopDownNode extends Node {
         node = new TopDownNode(id, e, self);
         node.groupId = groupId;
         children.set(id, node);
+      } else {
+        node.events.push(e);
       }
       node.selfTime += duration;
       node.totalTime += duration;
@@ -191,8 +200,8 @@ export class TopDownNode extends Node {
      * is a child of this node. As the check is done, the partial result
      * is cached on `matchedDepth`, for future checks.
      */
-    function matchPath(e: Trace.Types.Events.Event): boolean {
-      const {endTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(e);
+    function matchPath(e: Types.Events.Event): boolean {
+      const {endTime} = Helpers.Timing.eventTimingsMilliSeconds(e);
       if (matchedDepth === path.length) {
         return true;
       }
@@ -236,27 +245,31 @@ export class TopDownNode extends Node {
 }
 
 export class TopDownRootNode extends TopDownNode {
-  readonly filter: (e: Trace.Types.Events.Event) => boolean;
-  readonly events: Trace.Types.Events.Event[];
-  readonly startTime: Trace.Types.Timing.MilliSeconds;
-  readonly endTime: Trace.Types.Timing.MilliSeconds;
-  eventGroupIdCallback: ((arg0: Trace.Types.Events.Event) => string)|null|undefined;
+  readonly filter: (e: Types.Events.Event) => boolean;
+  readonly startTime: Types.Timing.MilliSeconds;
+  readonly endTime: Types.Timing.MilliSeconds;
+  eventGroupIdCallback: ((arg0: Types.Events.Event) => string)|null|undefined;
+  /** Default behavior is to aggregate similar trace events into one Node based on generateEventID(), eventGroupIdCallback(), etc. Set true to keep nodes 1:1 with events. */
   readonly doNotAggregate: boolean|undefined;
+  readonly includeInstantEvents?: boolean;
   override totalTime: number;
   override selfTime: number;
 
   constructor(
-      events: Trace.Types.Events.Event[], filters: TimelineModelFilter[], startTime: Trace.Types.Timing.MilliSeconds,
-      endTime: Trace.Types.Timing.MilliSeconds, doNotAggregate?: boolean,
-      eventGroupIdCallback?: ((arg0: Trace.Types.Events.Event) => string)|null) {
-    super('', null, null);
+      events: Types.Events.Event[], filters: TraceFilter[], startTime: Types.Timing.MilliSeconds,
+      endTime: Types.Timing.MilliSeconds, doNotAggregate?: boolean,
+      eventGroupIdCallback?: ((arg0: Types.Events.Event) => string)|null, includeInstantEvents?: boolean) {
+    super('', events[0], null);
+    this.event = events[0];
     this.root = this;
     this.events = events;
-    this.filter = (e: Trace.Types.Events.Event): boolean => filters.every(f => f.accept(e));
+    this.filter = (e: Types.Events.Event): boolean => filters.every(f => f.accept(e));
     this.startTime = startTime;
     this.endTime = endTime;
     this.eventGroupIdCallback = eventGroupIdCallback;
     this.doNotAggregate = doNotAggregate;
+    this.includeInstantEvents = includeInstantEvents;
+
     this.totalTime = endTime - startTime;
     this.selfTime = this.totalTime;
   }
@@ -275,14 +288,13 @@ export class TopDownRootNode extends TopDownNode {
     }
     const groupNodes = new Map<string, GroupNode>();
     for (const node of flatNodes.values()) {
-      if (!node.event) {
-        continue;
-      }
       const groupId = this.eventGroupIdCallback(node.event);
       let groupNode = groupNodes.get(groupId);
       if (!groupNode) {
-        groupNode = new GroupNode(groupId, this, node.event);
+        groupNode = new GroupNode(groupId, this, node.events);
         groupNodes.set(groupId, groupNode);
+      } else {
+        groupNode.events.push(...node.events);
       }
       groupNode.addChild(node as BottomUpNode, node.selfTime, node.totalTime);
     }
@@ -290,30 +302,29 @@ export class TopDownRootNode extends TopDownNode {
     return groupNodes;
   }
 
-  getEventGroupIdCallback(): ((arg0: Trace.Types.Events.Event) => string)|null|undefined {
+  getEventGroupIdCallback(): ((arg0: Types.Events.Event) => string)|null|undefined {
     return this.eventGroupIdCallback;
   }
 }
 
 export class BottomUpRootNode extends Node {
   private childrenInternal: ChildrenCache|null;
-  readonly events: Trace.Types.Events.Event[];
-  private textFilter: TimelineModelFilter;
-  readonly filter: (e: Trace.Types.Events.Event) => boolean;
-  readonly startTime: Trace.Types.Timing.MilliSeconds;
-  readonly endTime: Trace.Types.Timing.MilliSeconds;
-  private eventGroupIdCallback: ((arg0: Trace.Types.Events.Event) => string)|null;
+  private textFilter: TraceFilter;
+  readonly filter: (e: Types.Events.Event) => boolean;
+  readonly startTime: Types.Timing.MilliSeconds;
+  readonly endTime: Types.Timing.MilliSeconds;
+  private eventGroupIdCallback: ((arg0: Types.Events.Event) => string)|null;
   override totalTime: number;
 
   constructor(
-      events: Trace.Types.Events.Event[], textFilter: TimelineModelFilter, filters: TimelineModelFilter[],
-      startTime: Trace.Types.Timing.MilliSeconds, endTime: Trace.Types.Timing.MilliSeconds,
-      eventGroupIdCallback: ((arg0: Trace.Types.Events.Event) => string)|null) {
-    super('', null);
+      events: Types.Events.Event[], textFilter: TraceFilter, filters: TraceFilter[],
+      startTime: Types.Timing.MilliSeconds, endTime: Types.Timing.MilliSeconds,
+      eventGroupIdCallback: ((arg0: Types.Events.Event) => string)|null) {
+    super('', events[0]);
     this.childrenInternal = null;
     this.events = events;
     this.textFilter = textFilter;
-    this.filter = (e: Trace.Types.Events.Event): boolean => filters.every(f => f.accept(e));
+    this.filter = (e: Types.Events.Event): boolean => filters.every(f => f.accept(e));
     this.startTime = startTime;
     this.endTime = endTime;
     this.eventGroupIdCallback = eventGroupIdCallback;
@@ -349,20 +360,20 @@ export class BottomUpRootNode extends Node {
     const selfTimeStack: number[] = [endTime - startTime];
     const firstNodeStack: boolean[] = [];
     const totalTimeById = new Map<string, number>();
-    Trace.Helpers.Trace.forEachEvent(
+    Helpers.Trace.forEachEvent(
         this.events,
         {
           onStartEvent,
           onEndEvent,
-          startTime: Trace.Helpers.Timing.millisecondsToMicroseconds(this.startTime),
-          endTime: Trace.Helpers.Timing.millisecondsToMicroseconds(this.endTime),
+          startTime: Helpers.Timing.millisecondsToMicroseconds(this.startTime),
+          endTime: Helpers.Timing.millisecondsToMicroseconds(this.endTime),
           eventFilter: this.filter,
           ignoreAsyncEvents: false,
         },
     );
 
-    function onStartEvent(e: Trace.Types.Events.Event): void {
-      const {startTime: currentStartTime, endTime: currentEndTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(e);
+    function onStartEvent(e: Types.Events.Event): void {
+      const {startTime: currentStartTime, endTime: currentEndTime} = Helpers.Timing.eventTimingsMilliSeconds(e);
 
       const actualEndTime = currentEndTime !== undefined ? Math.min(currentEndTime, endTime) : endTime;
       const duration = actualEndTime - Math.max(currentStartTime, startTime);
@@ -376,12 +387,14 @@ export class BottomUpRootNode extends Node {
       firstNodeStack.push(noNodeOnStack);
     }
 
-    function onEndEvent(event: Trace.Types.Events.Event): void {
+    function onEndEvent(event: Types.Events.Event): void {
       const id = generateEventID(event);
       let node = nodeById.get(id);
       if (!node) {
         node = new BottomUpNode(root, id, event, false, root);
         nodeById.set(id, node);
+      } else {
+        node.events.push(event);
       }
       node.selfTime += selfTimeStack.pop() || 0;
       if (firstNodeStack.pop()) {
@@ -409,14 +422,13 @@ export class BottomUpRootNode extends Node {
     }
     const groupNodes = new Map<string, GroupNode>();
     for (const node of flatNodes.values()) {
-      if (!node.event) {
-        continue;
-      }
       const groupId = this.eventGroupIdCallback(node.event);
       let groupNode = groupNodes.get(groupId);
       if (!groupNode) {
-        groupNode = new GroupNode(groupId, this, node.event);
+        groupNode = new GroupNode(groupId, this, node.events);
         groupNodes.set(groupId, groupNode);
+      } else {
+        groupNode.events.push(...node.events);
       }
       groupNode.addChild(node as BottomUpNode, node.selfTime, node.selfTime);
     }
@@ -427,9 +439,11 @@ export class BottomUpRootNode extends Node {
 export class GroupNode extends Node {
   private readonly childrenInternal: ChildrenCache;
   override isGroupNodeInternal: boolean;
+  override events: Types.Events.Event[];
 
-  constructor(id: string, parent: BottomUpRootNode|TopDownRootNode, event: Trace.Types.Events.Event) {
-    super(id, event);
+  constructor(id: string, parent: BottomUpRootNode|TopDownRootNode, events: Types.Events.Event[]) {
+    super(id, events[0]);
+    this.events = events;
     this.childrenInternal = new Map();
     this.parent = parent;
     this.isGroupNodeInternal = true;
@@ -458,7 +472,7 @@ export class BottomUpNode extends Node {
   private cachedChildren: ChildrenCache|null;
   private hasChildrenInternal: boolean;
 
-  constructor(root: BottomUpRootNode, id: string, event: Trace.Types.Events.Event, hasChildren: boolean, parent: Node) {
+  constructor(root: BottomUpRootNode, id: string, event: Types.Events.Event, hasChildren: boolean, parent: Node) {
     super(id, event);
     this.parent = parent;
     this.root = root;
@@ -481,25 +495,25 @@ export class BottomUpNode extends Node {
     }
     const selfTimeStack: number[] = [0];
     const eventIdStack: string[] = [];
-    const eventStack: Trace.Types.Events.Event[] = [];
+    const eventStack: Types.Events.Event[] = [];
     const nodeById = new Map<string, BottomUpNode>();
     const startTime = this.root.startTime;
     const endTime = this.root.endTime;
     let lastTimeMarker: number = startTime;
     const self = this;
-    Trace.Helpers.Trace.forEachEvent(
+    Helpers.Trace.forEachEvent(
         this.root.events,
         {
           onStartEvent,
           onEndEvent,
-          startTime: Trace.Helpers.Timing.millisecondsToMicroseconds(startTime),
-          endTime: Trace.Helpers.Timing.millisecondsToMicroseconds(endTime),
+          startTime: Helpers.Timing.millisecondsToMicroseconds(startTime),
+          endTime: Helpers.Timing.millisecondsToMicroseconds(endTime),
           eventFilter: this.root.filter,
           ignoreAsyncEvents: false,
         },
     );
-    function onStartEvent(e: Trace.Types.Events.Event): void {
-      const {startTime: currentStartTime, endTime: currentEndTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(e);
+    function onStartEvent(e: Types.Events.Event): void {
+      const {startTime: currentStartTime, endTime: currentEndTime} = Helpers.Timing.eventTimingsMilliSeconds(e);
       const actualEndTime = currentEndTime !== undefined ? Math.min(currentEndTime, endTime) : endTime;
       const duration = actualEndTime - Math.max(currentStartTime, startTime);
       if (duration < 0) {
@@ -512,8 +526,8 @@ export class BottomUpNode extends Node {
       eventStack.push(e);
     }
 
-    function onEndEvent(e: Trace.Types.Events.Event): void {
-      const {startTime: currentStartTime, endTime: currentEndTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(e);
+    function onEndEvent(e: Types.Events.Event): void {
+      const {startTime: currentStartTime, endTime: currentEndTime} = Helpers.Timing.eventTimingsMilliSeconds(e);
       const selfTime = selfTimeStack.pop();
       const id = eventIdStack.pop();
       eventStack.pop();
@@ -533,6 +547,8 @@ export class BottomUpNode extends Node {
         const hasChildren = eventStack.length > self.depth;
         node = new BottomUpNode(self.root, childId, event, hasChildren, self);
         nodeById.set(childId, node);
+      } else {
+        node.events.push(e);
       }
       const actualEndTime = currentEndTime !== undefined ? Math.min(currentEndTime, endTime) : endTime;
       const totalTime = actualEndTime - Math.max(currentStartTime, lastTimeMarker);
@@ -545,7 +561,7 @@ export class BottomUpNode extends Node {
     return this.cachedChildren;
   }
 
-  override searchTree(matchFunction: (arg0: Trace.Types.Events.Event) => boolean, results?: Node[]): Node[] {
+  override searchTree(matchFunction: (arg0: Types.Events.Event) => boolean, results?: Node[]): Node[] {
     results = results || [];
     if (this.event && matchFunction(this.event)) {
       results.push(this);
@@ -554,8 +570,8 @@ export class BottomUpNode extends Node {
   }
 }
 
-export function eventStackFrame(event: Trace.Types.Events.Event): Protocol.Runtime.CallFrame|null {
-  if (Trace.Types.Events.isProfileCall(event)) {
+export function eventStackFrame(event: Types.Events.Event): Protocol.Runtime.CallFrame|null {
+  if (Types.Events.isProfileCall(event)) {
     return event.callFrame;
   }
   const topFrame = event.args?.data?.stackTrace?.[0];
@@ -565,8 +581,8 @@ export function eventStackFrame(event: Trace.Types.Events.Event): Protocol.Runti
   return {...topFrame, scriptId: String(topFrame.scriptId) as Protocol.Runtime.ScriptId};
 }
 
-export function generateEventID(event: Trace.Types.Events.Event): string {
-  if (Trace.Types.Events.isProfileCall(event)) {
+export function generateEventID(event: Types.Events.Event): string {
+  if (Types.Events.isProfileCall(event)) {
     const name = TimelineJSProfileProcessor.isNativeRuntimeFrame(event.callFrame) ?
         TimelineJSProfileProcessor.nativeGroup(event.callFrame.functionName) :
         event.callFrame.functionName;
@@ -574,7 +590,7 @@ export function generateEventID(event: Trace.Types.Events.Event): string {
     return `f:${name}@${location}`;
   }
 
-  if (Trace.Types.Events.isTimeStamp(event)) {
+  if (Types.Events.isTimeStamp(event)) {
     return `${event.name}:${event.args.data.message}`;
   }
 

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

@@ -7,12 +7,13 @@ import type * as Handlers from '../handlers/handlers.js';
 import * as Types from '../types/types.js';
 
 /**
- * Use this helper whenever resolving an URL's source mapping is not an
- * option. For example when processing non-ui data. Otherwise use the
- * helper SourceMapsResolver::resolvedURLForEntry
+ * INSTEAD, you probably want `SourceMapsResolver.resolvedURLForEntry()`!
+ * If an URL will be displayed in the UI, it's likely you should NOT use `getNonResolved`.
  *
- * If an URL will be displayed in the UI, it's likely you should not use
- * this helper and prefer the other option instead.
+ * Use `getNonResolved` method whenever resolving an URL's source mapping is not an
+ * option. For example when processing non-ui data.
+ *
+ * TODO: migrate existing uses of this over to resolvedURLForEntry.
  */
 
 export function getNonResolved(

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

@@ -7,4 +7,7 @@ export * as FilmStrip from './FilmStrip.js';
 export * as MainThreadActivity from './MainThreadActivity.js';
 export * as Metadata from './Metadata.js';
 export * as ThirdParties from './ThirdParties.js';
+export * as TimelineJSProfile from './TimelineJSProfile.js';
+export * as TraceFilter from './TraceFilter.js';
+export * as TraceTree from './TraceTree.js';
 export * as URLForEntry from './URLForEntry.js';

package/front_end/models/trace/handlers/AnimationHandler.ts

@@ -5,15 +5,12 @@
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
-import {HandlerState} from './types.js';
-
 const animations: Types.Events.Animation[] = [];
 const animationsSyntheticEvents: Types.Events.SyntheticAnimationPair[] = [];
 
 export interface AnimationData {
   animations: readonly Types.Events.SyntheticAnimationPair[];
 }
-let handlerState = HandlerState.UNINITIALIZED;
 
 export function reset(): void {
   animations.length = 0;
@@ -30,14 +27,9 @@ export function handleEvent(event: Types.Events.Event): void {
 export async function finalize(): Promise<void> {
   const syntheticEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(animations);
   animationsSyntheticEvents.push(...syntheticEvents);
-  handlerState = HandlerState.FINALIZED;
 }
 
 export function data(): AnimationData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('Animation handler is not finalized');
-  }
-
   return {
     animations: animationsSyntheticEvents,
   };

package/front_end/models/trace/handlers/ExtensionTraceDataHandler.ts

@@ -5,7 +5,7 @@
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
-import {type HandlerName, HandlerState} from './types.js';
+import type {HandlerName} from './types.js';
 import {data as userTimingsData} from './UserTimingsHandler.js';
 
 const extensionFlameChartEntries: Types.Extensions.SyntheticExtensionTrackEntry[] = [];
@@ -18,14 +18,12 @@ export interface ExtensionTraceData {
   extensionMarkers: readonly Types.Extensions.SyntheticExtensionMarker[];
   entryToNode: Map<Types.Events.Event, Helpers.TreeHelpers.TraceEntryNode>;
 }
-let handlerState = HandlerState.UNINITIALIZED;
 
 export function handleEvent(_event: Types.Events.Event): void {
   // Implementation not needed because data is sourced from UserTimingsHandler
 }
 
 export function reset(): void {
-  handlerState = HandlerState.INITIALIZED;
   extensionFlameChartEntries.length = 0;
   extensionTrackData.length = 0;
   extensionMarkers.length = 0;
@@ -33,11 +31,7 @@ export function reset(): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('ExtensionTraceData handler is not initialized');
-  }
   createExtensionFlameChartEntries();
-  handlerState = HandlerState.FINALIZED;
 }
 
 function createExtensionFlameChartEntries(): void {
@@ -120,10 +114,6 @@ export function extensionDataInTiming(timing: Types.Events.SyntheticUserTimingPa
 }
 
 export function data(): ExtensionTraceData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('ExtensionTraceData handler is not finalized');
-  }
-
   return {
     entryToNode,
     extensionTrackData: [...extensionTrackData],

package/front_end/models/trace/handlers/FramesHandler.test.ts

@@ -19,9 +19,6 @@ async function processTrace(events: readonly Trace.Types.Events.Event[]): Promis
   for (const handlerName of handlersInOrder) {
     const handler = Trace.Handlers.ModelHandlers[handlerName];
     handler.reset();
-    if ('initialize' in handler) {
-      handler.initialize();
-    }
   }
   for (const event of events) {
     for (const handlerName of handlersInOrder) {
@@ -30,9 +27,7 @@ async function processTrace(events: readonly Trace.Types.Events.Event[]): Promis
   }
   for (const handlerName of handlersInOrder) {
     const handler = Trace.Handlers.ModelHandlers[handlerName];
-    if ('finalize' in handler) {
-      await handler.finalize();
-    }
+    await handler.finalize();
   }
 }
 

package/front_end/models/trace/handlers/FramesHandler.ts

@@ -11,7 +11,7 @@ import {data as layerTreeHandlerData, type LayerTreeData} from './LayerTreeHandl
 import {data as metaHandlerData, type MetaHandlerData} from './MetaHandler.js';
 import {data as rendererHandlerData, type RendererHandlerData} from './RendererHandler.js';
 import * as Threads from './Threads.js';
-import {type HandlerName, HandlerState} from './types.js';
+import type {HandlerName} from './types.js';
 
 /**
  * IMPORTANT: this handler is slightly different to the rest. This is because
@@ -23,32 +23,19 @@ import {type HandlerName, HandlerState} from './types.js';
  *
  * In time we expect to migrate this code to a more "typical" handler.
  */
-let handlerState = HandlerState.UNINITIALIZED;
 
 const allEvents: Types.Events.Event[] = [];
 let model: TimelineFrameModel|null = null;
 
 export function reset(): void {
-  handlerState = HandlerState.UNINITIALIZED;
   allEvents.length = 0;
 }
-export function initialize(): void {
-  if (handlerState !== HandlerState.UNINITIALIZED) {
-    throw new Error('FramesHandler was not reset before being initialized');
-  }
-
-  handlerState = HandlerState.INITIALIZED;
-}
 
 export function handleEvent(event: Types.Events.Event): void {
   allEvents.push(event);
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('FramesHandler is not initialized');
-  }
-
   // Snapshot events can be emitted out of order, so we need to sort before
   // building the frames model.
   Helpers.Trace.sortTraceEventsInPlace(allEvents);

package/front_end/models/trace/handlers/GPUHandler.test.ts

@@ -8,8 +8,6 @@ import * as Trace from '../trace.js';
 describe('GPUHandler', function() {
   beforeEach(() => {
     Trace.Handlers.ModelHandlers.Meta.reset();
-    Trace.Handlers.ModelHandlers.Meta.initialize();
-    Trace.Handlers.ModelHandlers.GPU.initialize();
   });
 
   it('finds all the GPU Tasks for the main GPU Thread', async function() {

package/front_end/models/trace/handlers/GPUHandler.ts

@@ -6,9 +6,7 @@ import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
 import {data as metaHandlerData} from './MetaHandler.js';
-import {type HandlerName, HandlerState} from './types.js';
-
-let handlerState = HandlerState.UNINITIALIZED;
+import type {HandlerName} from './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.
@@ -19,23 +17,9 @@ let mainGPUThreadTasks: Types.Events.GPUTask[] = [];
 export function reset(): void {
   eventsInProcessThread.clear();
   mainGPUThreadTasks = [];
-
-  handlerState = HandlerState.UNINITIALIZED;
-}
-
-export function initialize(): void {
-  if (handlerState !== HandlerState.UNINITIALIZED) {
-    throw new Error('GPU Handler was not reset before being initialized');
-  }
-
-  handlerState = HandlerState.INITIALIZED;
 }
 
 export function handleEvent(event: Types.Events.Event): void {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('GPU Handler is not initialized');
-  }
-
   if (!Types.Events.isGPUTask(event)) {
     return;
   }
@@ -44,16 +28,11 @@ export function handleEvent(event: Types.Events.Event): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('GPU Handler is not initialized');
-  }
-
   const {gpuProcessId, gpuThreadId} = metaHandlerData();
   const gpuThreadsForProcess = eventsInProcessThread.get(gpuProcessId);
   if (gpuThreadsForProcess && gpuThreadId) {
     mainGPUThreadTasks = gpuThreadsForProcess.get(gpuThreadId) || [];
   }
-  handlerState = HandlerState.FINALIZED;
 }
 
 export interface GPUHandlerReturnData {
@@ -61,9 +40,6 @@ export interface GPUHandlerReturnData {
 }
 
 export function data(): GPUHandlerReturnData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('GPU Handler is not finalized');
-  }
   return {
     mainGPUThreadTasks,
   };