Remove TimelineJSProfile by merging it into SamplesIntegrator

- Move createFakeTraceFromCpuProfile to SamplesIntegrator static. Hard to say it *belongs* there, but it's a decent home.
- DRY up duplicate nativeGroup impl; SamplesIntegrator's existing one gets a const enum upgrade.

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

Author: paulirish

config/gni/devtools_grd_files.gni

@@ -1095,7 +1095,6 @@ grd_files_debug_sources = [
   "front_end/models/trace/extras/ScriptDuplication.js",
   "front_end/models/trace/extras/StackTraceForEvent.js",
   "front_end/models/trace/extras/ThirdParties.js",
-  "front_end/models/trace/extras/TimelineJSProfile.js",
   "front_end/models/trace/extras/TraceFilter.js",
   "front_end/models/trace/extras/TraceTree.js",
   "front_end/models/trace/handlers/AnimationFramesHandler.js",

front_end/models/trace/extras/BUILD.gn

@@ -16,7 +16,6 @@ devtools_module("extras") {
     "ScriptDuplication.ts",
     "StackTraceForEvent.ts",
     "ThirdParties.ts",
-    "TimelineJSProfile.ts",
     "TraceFilter.ts",
     "TraceTree.ts",
   ]

front_end/models/trace/extras/TimelineJSProfile.ts

@@ -4,9 +4,9 @@
 
 import type * as Protocol from '../../../generated/protocol.js';
 import * as Helpers from '../helpers/helpers.js';
+import {SamplesIntegrator} from '../helpers/SamplesIntegrator.js';
 import * as Types from '../types/types.js';
 
-import {TimelineJSProfileProcessor} from './TimelineJSProfile.js';
 import type {TraceFilter} from './TraceFilter.js';
 
 export class Node {
@@ -591,8 +591,8 @@ export function eventStackFrame(event: Types.Events.Event): Protocol.Runtime.Cal
 
 export function generateEventID(event: Types.Events.Event): string {
   if (Types.Events.isProfileCall(event)) {
-    const name = TimelineJSProfileProcessor.isNativeRuntimeFrame(event.callFrame) ?
-        TimelineJSProfileProcessor.nativeGroup(event.callFrame.functionName) :
+    const name = SamplesIntegrator.isNativeRuntimeFrame(event.callFrame) ?
+        SamplesIntegrator.nativeGroup(event.callFrame.functionName) :
         event.callFrame.functionName;
     const location = event.callFrame.scriptId || event.callFrame.url || '';
     return `f:${name}@${location}`;

front_end/models/trace/extras/TraceTree.ts

@@ -9,6 +9,5 @@ export * as Metadata from './Metadata.js';
 export * as ScriptDuplication from './ScriptDuplication.js';
 export * as StackTraceForEvent from './StackTraceForEvent.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';

front_end/models/trace/extras/extras.ts

@@ -29,7 +29,7 @@ async function handleEventsFromCpuProfile(context: Mocha.Context|Mocha.Suite|nul
     Promise<Trace.Handlers.ModelHandlers.Samples.SamplesHandlerData> {
   const profile = await TraceLoader.rawCPUProfile(context, name);
 
-  const contents = Trace.Extras.TimelineJSProfile.TimelineJSProfileProcessor.createFakeTraceFromCpuProfile(
+  const contents = Trace.Helpers.SamplesIntegrator.SamplesIntegrator.createFakeTraceFromCpuProfile(
       profile, Trace.Types.Events.ThreadID(1));
 
   Trace.Handlers.ModelHandlers.Samples.reset();

front_end/models/trace/handlers/SamplesHandler.test.ts

@@ -39,7 +39,7 @@ describeWithEnvironment('Handler Threads helper', function() {
     // it takes the CDP Profile and wraps it in fake trace events, before then
     // passing that through to the new engine.
     const profile = await TraceLoader.rawCPUProfile(this, 'node-fibonacci-website.cpuprofile.gz');
-    const contents = Trace.Extras.TimelineJSProfile.TimelineJSProfileProcessor.createFakeTraceFromCpuProfile(
+    const contents = Trace.Helpers.SamplesIntegrator.SamplesIntegrator.createFakeTraceFromCpuProfile(
         profile,
         Trace.Types.Events.ThreadID(1),
     );

front_end/models/trace/handlers/Threads.test.ts

@@ -458,12 +458,12 @@ export class SamplesIntegrator {
     return runtimeCallStatsEnabled && Boolean(SamplesIntegrator.nativeGroup(name));
   }
 
-  static nativeGroup(nativeName: string): 'Parse'|'Compile'|null {
+  static nativeGroup(nativeName: string): SamplesIntegrator.NativeGroups|null {
     if (nativeName.startsWith('Parse')) {
-      return 'Parse';
+      return SamplesIntegrator.NativeGroups.PARSE;
     }
     if (nativeName.startsWith('Compile') || nativeName.startsWith('Recompile')) {
-      return 'Compile';
+      return SamplesIntegrator.NativeGroups.COMPILE;
     }
     return null;
   }
@@ -496,4 +496,59 @@ export class SamplesIntegrator {
     }
     stack.length = j;
   }
+
+  static createFakeTraceFromCpuProfile(profile: Protocol.Profiler.Profile, tid: Types.Events.ThreadID):
+      Types.File.TraceFile {
+    const events: Types.Events.Event[] = [];
+
+    const threadName = `Thread ${tid}`;
+    appendEvent('TracingStartedInPage', {data: {sessionId: '1'}}, 0, 0, Types.Events.Phase.METADATA);
+    appendEvent(Types.Events.Name.THREAD_NAME, {name: threadName}, 0, 0, Types.Events.Phase.METADATA, '__metadata');
+    if (!profile) {
+      return {traceEvents: events, metadata: {}};
+    }
+
+    // Append a root to show the start time of the profile (which is earlier than first sample), so the Performance
+    // panel won't truncate this time period.
+    // 'JSRoot' doesn't exist in the new engine and is not the name of an actual trace event, but changing it might break other trace processing tools that rely on this, so we stick with this name.
+    // TODO(crbug.com/341234884): consider removing this or clarify why it's required.
+    appendEvent(
+        'JSRoot', {}, profile.startTime, profile.endTime - profile.startTime, Types.Events.Phase.COMPLETE, 'toplevel');
+
+    // TODO: create a `Profile` event instead, as `cpuProfile` is legacy
+    appendEvent('CpuProfile', {data: {cpuProfile: profile}}, profile.endTime, 0, Types.Events.Phase.COMPLETE);
+    return {
+      traceEvents: events,
+      metadata: {
+        dataOrigin: Types.File.DataOrigin.CPU_PROFILE,
+      }
+    };
+
+    function appendEvent(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        name: string, args: any, ts: number, dur?: number, ph?: Types.Events.Phase, cat?: string): Types.Events.Event {
+      const event: Types.Events.Event = {
+        cat: cat || 'disabled-by-default-devtools.timeline',
+        name,
+        ph: ph || Types.Events.Phase.COMPLETE,
+        pid: Types.Events.ProcessID(1),
+        tid,
+        ts: Types.Timing.Micro(ts),
+        args,
+      };
+
+      if (dur) {
+        event.dur = Types.Timing.Micro(dur);
+      }
+      events.push(event);
+      return event;
+    }
+  }
+}
+
+export namespace SamplesIntegrator {
+  export const enum NativeGroups {
+    COMPILE = 'Compile',
+    PARSE = 'Parse',
+  }
 }

front_end/models/trace/helpers/SamplesIntegrator.ts

@@ -504,7 +504,7 @@ export function frameIDForEvent(event: Types.Events.Event): string|null {
 const DevToolsTimelineEventCategory = 'disabled-by-default-devtools.timeline';
 export function isTopLevelEvent(event: Types.Events.Event): boolean {
   if (event.name === 'JSRoot' && event.cat === 'toplevel') {
-    // This is used in TimelineJSProfile to insert a fake event prior to the
+    // This is used in createFakeTraceFromCpuProfile to insert a fake event prior to the
     // CPU Profile in order to ensure the trace isn't truncated. So if we see
     // this, we want to treat it as a top level event.
     // TODO(crbug.com/341234884): do we need this?

front_end/models/trace/helpers/Trace.ts

@@ -88,7 +88,7 @@ export class TimelineLoader implements Common.StringOutputStream.OutputStream {
     loader.#traceIsCPUProfile = true;
 
     try {
-      const contents = Trace.Extras.TimelineJSProfile.TimelineJSProfileProcessor.createFakeTraceFromCpuProfile(
+      const contents = Trace.Helpers.SamplesIntegrator.SamplesIntegrator.createFakeTraceFromCpuProfile(
           profile, Trace.Types.Events.ThreadID(1));
 
       window.setTimeout(async () => {
@@ -261,7 +261,7 @@ export class TimelineLoader implements Common.StringOutputStream.OutputStream {
   }
 
   #parseCPUProfileFormatFromFile(parsedTrace: Protocol.Profiler.Profile): void {
-    const traceFile = Trace.Extras.TimelineJSProfile.TimelineJSProfileProcessor.createFakeTraceFromCpuProfile(
+    const traceFile = Trace.Helpers.SamplesIntegrator.SamplesIntegrator.createFakeTraceFromCpuProfile(
         parsedTrace, Trace.Types.Events.ThreadID(1));
 
     this.#collectEvents(traceFile.traceEvents);