RPP: Remove handlerState from handlers

This removes the unused and inconsistent `handlerState` mechanism. It's provided limited value and adopted inconsistently.

Change-Id: I799a4d42998d9ee3a8b7121a4d7fbbd67ca19974
Bug: none
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/5988671
Commit-Queue: Paul Irish <[email protected]>
Reviewed-by: Jack Franklin <[email protected]>
Auto-Submit: Paul Irish <[email protected]>
Commit-Queue: Jack Franklin <[email protected]>

Author: paulirish

front_end/models/trace/Processor.test.ts

@@ -139,6 +139,7 @@ describeWithEnvironment('TraceProcessor', function() {
     const baseHandler = {
       data() {},
       handleEvent() {},
+      async finalize() {},
       reset() {},
     };
 

front_end/models/trace/Processor.ts

@@ -52,6 +52,7 @@ declare global {
 export interface ParseOptions {
   /**
    * If the trace was just recorded on the current page, rather than an imported file.
+   * TODO(paulirish): Maybe remove. This is currently unused by the Processor and Handlers
    * @default false
    */
   isFreshRecording?: boolean;
@@ -170,7 +171,7 @@ export class TraceProcessor extends EventTarget {
     }
     try {
       this.#status = Status.PARSING;
-      await this.#computeParsedTrace(traceEvents, Boolean(options.isFreshRecording));
+      await this.#computeParsedTrace(traceEvents);
       if (this.#data && !options.isCPUProfile) {  // We do not calculate insights for CPU Profiles.
         this.#computeInsights(this.#data, traceEvents);
       }
@@ -184,7 +185,7 @@ export class TraceProcessor extends EventTarget {
   /**
    * Run all the handlers and set the result to `#data`.
    */
-  async #computeParsedTrace(traceEvents: readonly Types.Events.Event[], freshRecording: boolean): Promise<void> {
+  async #computeParsedTrace(traceEvents: readonly Types.Events.Event[]): Promise<void> {
     /**
      * We want to yield regularly to maintain responsiveness. If we yield too often, we're wasting idle time.
      * We could do this by checking `performance.now()` regularly, but it's an expensive call in such a hot loop.
@@ -202,11 +203,6 @@ export class TraceProcessor extends EventTarget {
       handler.reset();
     }
 
-    // Initialize.
-    for (const handler of sortedHandlers) {
-      handler.initialize?.(freshRecording);
-    }
-
     // Handle each event.
     for (let i = 0; i < traceEvents.length; ++i) {
       // Every so often we take a break just to render.

front_end/models/trace/README.md

@@ -21,7 +21,6 @@ This folder contains the new trace engine that was first implemented for the Per
 │NetworkRequestHandler│     │...many more handlers │
 │                     │     │                      │
 │     reset()         │     │                      │
-│     initialize()    │     │                      │
 │                     │     │                      │
 │     handleEvent()   │     │                      │
 │                     │     │                      │

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,
   };

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,26 +18,20 @@ 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;
   entryToNode.clear();
 }
 
 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],

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();
   }
 }
 

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);

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() {

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,26 +28,18 @@ 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 {
   mainGPUThreadTasks: readonly Types.Events.GPUTask[];
 }
 
 export function data(): GPUHandlerReturnData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('GPU Handler is not finalized');
-  }
   return {
     mainGPUThreadTasks,
   };

front_end/models/trace/handlers/ImagePaintingHandler.ts

@@ -112,6 +112,9 @@ export function handleEvent(event: Types.Events.Event): void {
   }
 }
 
+export async function finalize(): Promise<void> {
+}
+
 export interface ImagePaintData {
   paintImageByDrawLazyPixelRef: Map<number, Types.Events.PaintImage>;
   paintImageForEvent: Map<Types.Events.Event, Types.Events.PaintImage>;