Select one CPU profile stream per thread by source

DevTools merges concurrent CPU profile streams on the same thread, which
corrupts JavaScript attribution when multiple profiling sources are
active simultaneously. For example, when JS Self-Profiling API runs
concurrently with internal V8 tracing, their samples get incorrectly
merged into a single profile.

This CL ingests the optional args.data.source field on
"Profile"/"ProfileChunk" trace events and selects exactly one stream per
thread based on source priority. Models are built only for the chosen
stream, preventing corruption.

This enables reliable profiling when multiple sources are active, with
backward compatibility for profiles without source tags

Related CLs:
V8 CL: https://crrev.com/c/7004962
Chromium CL: https://crrev.com/c/6874588

Bug: 375614293
Change-Id: I4032b8570dfc7b70046ce5b7b979dc6f27306fda
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6877206
Reviewed-by: Jack Franklin <[email protected]>
Reviewed-by: Yang Guo <[email protected]>
Commit-Queue: Issack John <[email protected]>

Author: issackjohn

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

@@ -288,6 +288,277 @@ describeWithEnvironment('SamplesHandler', function() {
     });
   });
 
+  describe('profile source selection', () => {
+    const pid = Trace.Types.Events.ProcessID(42);
+    const tid = Trace.Types.Events.ThreadID(7);
+
+    type ProfileStreamEvent = Trace.Types.Events.Profile|Trace.Types.Events.ProfileChunk;
+
+    function makeProfileEvent(id: Trace.Types.Events.ProfileID, source: string): Trace.Types.Events.Profile {
+      return {
+        cat: '',
+        name: Trace.Types.Events.Name.PROFILE,
+        ph: Trace.Types.Events.Phase.SAMPLE,
+        pid,
+        tid,
+        ts: Trace.Types.Timing.Micro(0),
+        id,
+        args: {data: {startTime: Trace.Types.Timing.Micro(0), source: source as Trace.Types.Events.ProfileSource}},
+      };
+    }
+
+    function makeProfileChunkEvent(
+        id: Trace.Types.Events.ProfileID,
+        source: string,
+        samples: number[],
+        timeDeltas: number[],
+        nodes: Array<{id: number, children: number[]}> =
+            [
+              {id: 0, children: [1]},
+              {id: 1, children: []},
+            ],
+        ): Trace.Types.Events.ProfileChunk {
+      return {
+        cat: '',
+        name: Trace.Types.Events.Name.PROFILE_CHUNK,
+        ph: Trace.Types.Events.Phase.SAMPLE,
+        pid,
+        tid,
+        ts: Trace.Types.Timing.Micro(1),
+        id,
+        args: {
+          data: {
+            source: source as Trace.Types.Events.ProfileSource,
+            cpuProfile: {
+              samples: samples.map(Trace.Types.Events.CallFrameID),
+              nodes: nodes.map(n => ({
+                                 id: Trace.Types.Events.CallFrameID(n.id),
+                                 children: n.children,
+                                 callFrame: {functionName: '', scriptId: 0, columnNumber: 0, lineNumber: 0, url: ''},
+                               })),
+            },
+            timeDeltas: timeDeltas.map(Trace.Types.Timing.Micro),
+          },
+        },
+      };
+    }
+
+    function makeProfileStream({
+      id,
+      source,
+      samples = [1],
+      timeDeltas = [10],
+      nodes,
+    }: {
+      id: Trace.Types.Events.ProfileID,
+      source: string,
+      samples?: number[],
+      timeDeltas?: number[],
+      nodes?: Array<{id: number, children: number[]}>,
+    }): ProfileStreamEvent[] {
+      const events: ProfileStreamEvent[] = [];
+      events.push(makeProfileEvent(id, source));
+      events.push(makeProfileChunkEvent(id, source, samples, timeDeltas, nodes ?? [
+        {id: 0, children: [1]},
+        {id: 1, children: []},
+      ]));
+      return events;
+    }
+
+    async function runSelectionScenario(events: ProfileStreamEvent[], isCPUProfile = false) {
+      Trace.Handlers.ModelHandlers.Samples.reset();
+      Trace.Handlers.ModelHandlers.Meta.reset();
+
+      for (const event of events) {
+        Trace.Handlers.ModelHandlers.Samples.handleEvent(event);
+      }
+
+      await Trace.Handlers.ModelHandlers.Meta.finalize();
+      await Trace.Handlers.ModelHandlers.Samples.finalize({isCPUProfile});
+
+      const profileByThread = Trace.Handlers.ModelHandlers.Samples.data().profilesInProcess.get(pid);
+      assert.exists(profileByThread);
+      const selected = profileByThread?.get(tid);
+      assert.exists(selected);
+      return selected!;
+    }
+
+    it('selects Internal stream over SelfProfiling in performance trace', async () => {
+      const internalId = Trace.Types.Events.ProfileID('0xE');
+      const selfProfilingId = Trace.Types.Events.ProfileID('0xJ');
+
+      const selected = await runSelectionScenario([
+        ...makeProfileStream({
+          id: internalId,
+          source: 'Internal',
+        }),
+        ...makeProfileStream({
+          id: selfProfilingId,
+          source: 'SelfProfiling',
+        }),
+      ]);
+
+      assert.strictEqual(selected.profileId, internalId);
+    });
+
+    it('prefers Inspector stream over Internal in CPU profile mode', async () => {
+      const inspectorId = Trace.Types.Events.ProfileID('0xD');
+      const internalId = Trace.Types.Events.ProfileID('0xE');
+
+      const selected = await runSelectionScenario(
+          [
+            ...makeProfileStream({
+              id: inspectorId,
+              source: 'Inspector',
+            }),
+            ...makeProfileStream({
+              id: internalId,
+              source: 'Internal',
+            }),
+          ],
+          true);
+
+      assert.strictEqual(selected.profileId, inspectorId);
+    });
+
+    it('prefers Internal stream over Inspector in performance trace mode', async () => {
+      const internalId = Trace.Types.Events.ProfileID('0xI');
+      const inspectorId = Trace.Types.Events.ProfileID('0xD');
+
+      const selected = await runSelectionScenario([
+        ...makeProfileStream({
+          id: internalId,
+          source: 'Internal',
+        }),
+        ...makeProfileStream({
+          id: inspectorId,
+          source: 'Inspector',
+        }),
+      ]);
+
+      assert.strictEqual(selected.profileId, internalId);
+    });
+
+    it('selects complete priority order in CPU profile mode', async () => {
+      const inspectorId = Trace.Types.Events.ProfileID('0xD');
+      const internalId = Trace.Types.Events.ProfileID('0xE');
+      const selfProfilingId = Trace.Types.Events.ProfileID('0xJ');
+
+      const selected = await runSelectionScenario(
+          [
+            ...makeProfileStream({
+              id: selfProfilingId,
+              source: 'SelfProfiling',
+            }),
+            ...makeProfileStream({
+              id: internalId,
+              source: 'Internal',
+            }),
+            ...makeProfileStream({
+              id: inspectorId,
+              source: 'Inspector',
+            }),
+          ],
+          true);
+
+      assert.strictEqual(selected.profileId, inspectorId);
+    });
+
+    it('selects complete priority order in performance trace mode', async () => {
+      const inspectorId = Trace.Types.Events.ProfileID('0xD');
+      const internalId = Trace.Types.Events.ProfileID('0xE');
+      const selfProfilingId = Trace.Types.Events.ProfileID('0xJ');
+
+      const selected = await runSelectionScenario([
+        ...makeProfileStream({
+          id: selfProfilingId,
+          source: 'SelfProfiling',
+        }),
+        ...makeProfileStream({
+          id: inspectorId,
+          source: 'Inspector',
+        }),
+        ...makeProfileStream({
+          id: internalId,
+          source: 'Internal',
+        }),
+      ]);
+
+      assert.strictEqual(selected.profileId, internalId);
+    });
+
+    it('falls back to first candidate when no recognized sources exist', async () => {
+      const firstUnknownId = Trace.Types.Events.ProfileID('0xU1');
+      const secondUnknownId = Trace.Types.Events.ProfileID('0xU2');
+
+      const events: ProfileStreamEvent[] = [
+        ...makeProfileStream({
+          id: firstUnknownId,
+          source: 'Unspecified',
+        }),
+        ...makeProfileStream({
+          id: secondUnknownId,
+          source: 'CustomSource',
+        }),
+      ];
+
+      const selected = await runSelectionScenario(events);
+
+      // Falls back to candidates[0] when no priority matches
+      assert.strictEqual(selected.profileId, firstUnknownId);
+    });
+
+    it('ignores profiles with unknown sources in priority matching', async () => {
+      const inspectorId = Trace.Types.Events.ProfileID('0xD');
+      const unknownId = Trace.Types.Events.ProfileID('0xU');
+
+      const events: ProfileStreamEvent[] = [
+        ...makeProfileStream({
+          id: unknownId,
+          source: 'Unspecified',
+        }),
+        ...makeProfileStream({
+          id: inspectorId,
+          source: 'Inspector',
+        }),
+      ];
+
+      const selected = await runSelectionScenario(events, true);
+
+      assert.strictEqual(selected.profileId, inspectorId);
+    });
+
+    it('falls back to SelfProfiling when higher priority sources absent', async () => {
+      const selfProfilingId = Trace.Types.Events.ProfileID('0xJ');
+
+      const selected = await runSelectionScenario(
+          [
+            ...makeProfileStream({
+              id: selfProfilingId,
+              source: 'SelfProfiling',
+            }),
+          ],
+          true);
+
+      assert.strictEqual(selected.profileId, selfProfilingId);
+    });
+
+    it('selects available source even when not in priority list for CPU profile mode', async () => {
+      const internalId = Trace.Types.Events.ProfileID('0xE');
+
+      const selected = await runSelectionScenario(
+          [
+            ...makeProfileStream({
+              id: internalId,
+              source: 'Internal',
+            }),
+          ],
+          true);
+
+      assert.strictEqual(selected.profileId, internalId);
+    });
+  });
+
   describe('getProfileCallFunctionName', () => {
     /**
      * Find an event from the trace that represents some work. The use of