chrome-devtools-frontend 1.0.1473514 → 1.0.1506453

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

@@ -16,23 +16,28 @@ export type Entity = typeof ThirdPartyWeb.ThirdPartyWeb.entities[number]&{
 export interface EntityMappings {
   createdEntityCache: Map<string, Entity>;
   entityByEvent: Map<Types.Events.Event, Entity>;
-  /**
-   * This holds the entities that had to be created, because they were not found using the
-   * ThirdPartyWeb database.
-   */
   eventsByEntity: Map<Entity, Types.Events.Event[]>;
+  entityByUrlCache: Map<string, Entity>;
 }
 
-export function getEntityForEvent(event: Types.Events.Event, entityCache: Map<string, Entity>): Entity|undefined {
+export function getEntityForEvent(event: Types.Events.Event, entityMappings: EntityMappings): Entity|undefined {
   const url = getNonResolvedURL(event);
   if (!url) {
     return;
   }
-  return getEntityForUrl(url, entityCache);
+  return getEntityForUrl(url, entityMappings);
 }
 
-export function getEntityForUrl(url: string, entityCache: Map<string, Entity>): Entity|undefined {
-  return ThirdPartyWeb.ThirdPartyWeb.getEntity(url) ?? makeUpEntity(entityCache, url);
+export function getEntityForUrl(url: string, entityMappings: EntityMappings): Entity|undefined {
+  const cachedByUrl = entityMappings.entityByUrlCache.get(url);
+  if (cachedByUrl) {
+    return cachedByUrl;
+  }
+  const entity = ThirdPartyWeb.ThirdPartyWeb.getEntity(url) ?? makeUpEntity(entityMappings.createdEntityCache, url);
+  if (entity) {
+    entityMappings.entityByUrlCache.set(url, entity);
+  }
+  return entity;
 }
 
 export function getNonResolvedURL(
@@ -159,17 +164,17 @@ function makeUpChromeExtensionEntity(entityCache: Map<string, Entity>, url: stri
 }
 
 export function addEventToEntityMapping(event: Types.Events.Event, entityMappings: EntityMappings): void {
-  const entity = getEntityForEvent(event, entityMappings.createdEntityCache);
-  if (!entity) {
-    return;
-  }
-
   // As we share the entityMappings between Network and Renderer... We can have ResourceSendRequest events passed in here
   // that were already mapped in Network. So, to avoid mapping twice, we always check that we didn't yet.
   if (entityMappings.entityByEvent.has(event)) {
     return;
   }
 
+  const entity = getEntityForEvent(event, entityMappings);
+  if (!entity) {
+    return;
+  }
+
   const mappedEvents = entityMappings.eventsByEntity.get(entity);
   if (mappedEvents) {
     mappedEvents.push(event);
@@ -183,7 +188,7 @@ export function addEventToEntityMapping(event: Types.Events.Event, entityMapping
 export function addNetworkRequestToEntityMapping(
     networkRequest: Types.Events.SyntheticNetworkRequest, entityMappings: EntityMappings,
     requestTraceEvents: TraceEventsForNetworkRequest): void {
-  const entity = getEntityForEvent(networkRequest, entityMappings.createdEntityCache);
+  const entity = getEntityForEvent(networkRequest, entityMappings);
   if (!entity) {
     return;
   }

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

@@ -5,10 +5,14 @@
 import type * as Types from './../types/types.js';
 import type * as ModelHandlers from './ModelHandlers.js';
 
+export type FinalizeOptions = Types.Configuration.ParseOptions&{
+  allTraceEvents: readonly Types.Events.Event[],
+};
+
 export interface Handler {
   reset(): void;
   handleEvent(data: object): void;
-  finalize(options?: Types.Configuration.ParseOptions): Promise<void>;
+  finalize(options?: FinalizeOptions): Promise<void>;
   data(): unknown;
   deps?(): HandlerName[];
   handleUserConfig?(config: Types.Configuration.Configuration): void;

package/front_end/models/trace/helpers/SamplesIntegrator.test.ts

@@ -5,7 +5,7 @@
 import type * as Protocol from '../../../generated/protocol.js';
 import * as CPUProfile from '../../../models/cpu_profile/cpu_profile.js';
 import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
-import {makeCompleteEvent, makeInstantEvent} from '../../../testing/TraceHelpers.js';
+import {allThreadEntriesInTrace, makeCompleteEvent, makeInstantEvent} from '../../../testing/TraceHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 import * as Trace from '../trace.js';
 
@@ -101,7 +101,7 @@ describeWithEnvironment('SamplesIntegrator', function() {
       const parsedProfile = cpuProfileData.parsedProfile;
       const samplesIntegrator =
           new Trace.Helpers.SamplesIntegrator.SamplesIntegrator(parsedProfile, PROFILE_ID, pid, tid);
-      const traceEvents = parsedTrace.Renderer.allTraceEntries.filter(event => event.pid === pid && event.tid === tid);
+      const traceEvents = allThreadEntriesInTrace(parsedTrace).filter(event => event.pid === pid && event.tid === tid);
       if (!traceEvents) {
         throw new Error('Trace events were unexpectedly not found.');
       }
@@ -350,7 +350,7 @@ describeWithEnvironment('SamplesIntegrator', function() {
       const parsedProfile = cpuProfileData.parsedProfile;
       const samplesIntegrator =
           new Trace.Helpers.SamplesIntegrator.SamplesIntegrator(parsedProfile, PROFILE_ID, pid, tid);
-      const traceEvents = parsedTrace.Renderer.allTraceEntries.filter(event => event.pid === pid && event.tid === tid);
+      const traceEvents = allThreadEntriesInTrace(parsedTrace).filter(event => event.pid === pid && event.tid === tid);
       if (!traceEvents) {
         throw new Error('Trace events were unexpectedly not found.');
       }

package/front_end/models/trace/helpers/SamplesIntegrator.ts

@@ -498,50 +498,41 @@ export class SamplesIntegrator {
 
   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: {}};
+      return {traceEvents: [], metadata: {}};
     }
-
-    // Append a root to show the start time of the profile (which is earlier than first sample), so the Performance
+    // The |Name.CPU_PROFILE| will let MetaHandler to set |traceIsGeneric| to false
+    // The start time and duration is important here because we'll use them to determine the traceBounds
+    // We use the start and end time of the profile (which is longer than all samples), 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');
+    const cpuProfileEvent: Types.Events.SyntheticCpuProfile = {
+      cat: 'disabled-by-default-devtools.timeline',
+      name: Types.Events.Name.CPU_PROFILE,
+      ph: Types.Events.Phase.COMPLETE,
+      pid: Types.Events.ProcessID(1),
+      tid,
+      ts: Types.Timing.Micro(profile.startTime),
+      dur: Types.Timing.Micro(profile.endTime - profile.startTime),
+      args: {data: {cpuProfile: profile}},
+      // Create an arbitrary profile id.
+      id: '0x1' as Types.Events.ProfileID,
+    };
 
-    // 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,
+      traceEvents: [cpuProfileEvent],
       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;
+  static extractCpuProfileFromFakeTrace(traceEvents: readonly Types.Events.Event[]): Protocol.Profiler.Profile {
+    const profileEvent = traceEvents.find(e => Types.Events.isSyntheticCpuProfile(e));
+    const profile = profileEvent?.args.data.cpuProfile;
+    if (!profile) {
+      throw new Error('Missing cpuProfile data');
     }
+    return profile;
   }
 }
 

package/front_end/models/trace/helpers/SyntheticEvents.ts

@@ -40,7 +40,7 @@ export class SyntheticEventsManager {
 
   static registerSyntheticEvent<T extends Types.Events.SyntheticBased>(syntheticEvent: Omit<T, '_tag'>): T {
     try {
-      return SyntheticEventsManager.getActiveManager().registerSyntheticEvent(syntheticEvent);
+      return SyntheticEventsManager.getActiveManager().#registerSyntheticEvent(syntheticEvent);
     } catch {
       // If no active manager has been initialized, we assume the trace engine is
       // not running as part of the Performance panel. In this case we don't
@@ -59,7 +59,7 @@ export class SyntheticEventsManager {
    * be created with this method to ensure they are registered and made
    * available to load events using serialized keys.
    */
-  registerSyntheticEvent<T extends Types.Events.SyntheticBased>(syntheticEvent: Omit<T, '_tag'>): T {
+  #registerSyntheticEvent<T extends Types.Events.SyntheticBased>(syntheticEvent: Omit<T, '_tag'>): T {
     const rawIndex = this.#rawTraceEvents.indexOf(syntheticEvent.rawSourceEvent);
     if (rawIndex < 0) {
       throw new Error('Attempted to register a synthetic event paired to an unknown raw event.');

package/front_end/models/trace/helpers/Timing.ts

@@ -2,6 +2,7 @@
 // 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 Types from '../types/types.js';
 
 import {getNavigationForTraceEvent} from './Trace.js';
@@ -118,7 +119,7 @@ export function traceWindowFromMicroSeconds(
   const traceWindow: Types.Timing.TraceWindowMicro = {
     min,
     max,
-    range: Types.Timing.Micro(max - min),
+    range: (max - min) as Types.Timing.Micro,
   };
   return traceWindow;
 }
@@ -126,11 +127,73 @@ export function traceWindowFromMicroSeconds(
 export function traceWindowFromEvent(event: Types.Events.Event): Types.Timing.TraceWindowMicro {
   return {
     min: event.ts,
-    max: Types.Timing.Micro(event.ts + (event.dur ?? 0)),
-    range: event.dur ?? Types.Timing.Micro(0),
+    max: event.ts + (event.dur ?? 0) as Types.Timing.Micro,
+    range: event.dur ?? 0 as Types.Timing.Micro,
   };
 }
 
+export function traceWindowFromOverlay(overlay: Types.Overlays.Overlay): Types.Timing.TraceWindowMicro|null {
+  switch (overlay.type) {
+    case 'ENTRY_LABEL':
+    case 'ENTRY_OUTLINE':
+    case 'ENTRY_SELECTED': {
+      return traceWindowFromEvent(overlay.entry);
+    }
+
+    case 'TIMESPAN_BREAKDOWN': {
+      const windows = overlay.sections.map(s => s.bounds);
+      if (overlay.entry) {
+        windows.push(traceWindowFromEvent(overlay.entry));
+      }
+      return combineTraceWindowsMicro(windows);
+    }
+
+    case 'CANDY_STRIPED_TIME_RANGE':
+    case 'TIME_RANGE': {
+      return structuredClone(overlay.bounds);
+    }
+
+    case 'ENTRIES_LINK': {
+      const from = traceWindowFromEvent(overlay.entryFrom);
+      if (!overlay.entryTo) {
+        return from;
+      }
+
+      const to = traceWindowFromEvent(overlay.entryTo);
+      return combineTraceWindowsMicro([from, to]);
+    }
+
+    case 'TIMESTAMP_MARKER':
+      return traceWindowFromMicroSeconds(overlay.timestamp, overlay.timestamp);
+    case 'TIMINGS_MARKER':
+      return traceWindowFromMicroSeconds(overlay.adjustedTimestamp, overlay.adjustedTimestamp);
+    case 'BOTTOM_INFO_BAR':
+      return null;
+
+    default:
+      Platform.TypeScriptUtilities.assertNever(overlay, `Unexpected overlay ${overlay}`);
+  }
+}
+
+/**
+ * Combines (as in a union) multiple windows into one.
+ */
+export function combineTraceWindowsMicro(windows: Types.Timing.TraceWindowMicro[]): Types.Timing.TraceWindowMicro|null {
+  if (!windows.length) {
+    return null;
+  }
+
+  const result: Types.Timing.TraceWindowMicro = structuredClone(windows[0]);
+  for (const bounds of windows.slice(1)) {
+    result.min = Math.min(result.min, bounds.min) as Types.Timing.Micro;
+    result.max = Math.max(result.max, bounds.max) as Types.Timing.Micro;
+  }
+
+  result.range = result.max - result.min as Types.Timing.Micro;
+
+  return result;
+}
+
 export interface BoundsIncludeTimeRange {
   timeRange: Types.Timing.TraceWindowMicro;
   bounds: Types.Timing.TraceWindowMicro;

package/front_end/models/trace/helpers/Trace.test.ts

@@ -4,6 +4,7 @@
 
 import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
 import {
+  allThreadEntriesInTrace,
   getMainThread,
   makeAsyncEndEvent,
   makeAsyncStartEvent,
@@ -128,9 +129,7 @@ describeWithEnvironment('Trace helpers', function() {
       const fcp = PageLoadMetrics.metricScoresByFrameId.get(Meta.mainFrameId)
                       ?.get(firstNavigationId)
                       ?.get(Trace.Handlers.ModelHandlers.PageLoadMetrics.MetricName.FCP);
-      if (!fcp?.event) {
-        assert.fail('FCP not found');
-      }
+      assert.isOk(fcp?.event, 'FCP not found');
       const navigationForFirstRequest =
           Trace.Helpers.Trace.getNavigationForTraceEvent(fcp.event, Meta.mainFrameId, Meta.navigationsByFrameId);
       assert.strictEqual(navigationForFirstRequest?.args.data?.navigationId, firstNavigationId);
@@ -507,7 +506,7 @@ describeWithEnvironment('Trace helpers', function() {
   describe('frameIDForEvent', () => {
     it('returns the frame ID from beginData if the event has it', async function() {
       const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
-      const parseHTMLEvent = parsedTrace.Renderer.allTraceEntries.find(Trace.Types.Events.isParseHTML);
+      const parseHTMLEvent = allThreadEntriesInTrace(parsedTrace).find(Trace.Types.Events.isParseHTML);
       assert.isOk(parseHTMLEvent);
       const frameId = Trace.Helpers.Trace.frameIDForEvent(parseHTMLEvent);
       assert.isNotNull(frameId);
@@ -516,7 +515,7 @@ describeWithEnvironment('Trace helpers', function() {
 
     it('returns the frame ID from args.data if the event has it', async function() {
       const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
-      const invalidateLayoutEvent = parsedTrace.Renderer.allTraceEntries.find(Trace.Types.Events.isInvalidateLayout);
+      const invalidateLayoutEvent = allThreadEntriesInTrace(parsedTrace).find(Trace.Types.Events.isInvalidateLayout);
       assert.isOk(invalidateLayoutEvent);
       const frameId = Trace.Helpers.Trace.frameIDForEvent(invalidateLayoutEvent);
       assert.isNotNull(frameId);
@@ -525,7 +524,7 @@ describeWithEnvironment('Trace helpers', function() {
 
     it('returns null if the event does not have a frame', async function() {
       const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
-      const v8CompileEvent = parsedTrace.Renderer.allTraceEntries.find(Trace.Types.Events.isV8Compile);
+      const v8CompileEvent = allThreadEntriesInTrace(parsedTrace).find(Trace.Types.Events.isV8Compile);
       assert.isOk(v8CompileEvent);
       const frameId = Trace.Helpers.Trace.frameIDForEvent(v8CompileEvent);
       assert.isNull(frameId);
@@ -721,7 +720,7 @@ describeWithEnvironment('Trace helpers', function() {
   describe('isTopLevelEvent', () => {
     it('is true for a RunTask event', async function() {
       const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev.json.gz');
-      const runTask = parsedTrace.Renderer.allTraceEntries.find(Trace.Types.Events.isRunTask);
+      const runTask = allThreadEntriesInTrace(parsedTrace).find(Trace.Types.Events.isRunTask);
       assert.isOk(runTask);
 
       assert.isTrue(Trace.Helpers.Trace.isTopLevelEvent(runTask));

package/front_end/models/trace/helpers/Trace.ts

@@ -106,29 +106,36 @@ export function addEventToProcessThread<T extends Types.Events.Event>(
   eventsInProcessThread.set(event.pid, eventsInThread);
 }
 
-export interface TimeSpan {
-  ts: Types.Timing.Micro;
-  dur?: Types.Timing.Micro;
-}
-export function eventTimeComparator(a: Types.Events.Event, b: Types.Events.Event): -1|0|1 {
-  const aBeginTime = a.ts;
-  const bBeginTime = b.ts;
+export function compareBeginAndEnd(aBeginTime: number, bBeginTime: number, aEndTime: number, bEndTime: number): -1|0|1 {
   if (aBeginTime < bBeginTime) {
     return -1;
   }
   if (aBeginTime > bBeginTime) {
     return 1;
   }
-  const aDuration = a.dur ?? 0;
-  const bDuration = b.dur ?? 0;
-  const aEndTime = aBeginTime + aDuration;
-  const bEndTime = bBeginTime + bDuration;
+
   if (aEndTime > bEndTime) {
     return -1;
   }
   if (aEndTime < bEndTime) {
     return 1;
   }
+
+  return 0;
+}
+
+export function eventTimeComparator(a: Types.Events.Event, b: Types.Events.Event): -1|0|1 {
+  const aBeginTime = a.ts;
+  const bBeginTime = b.ts;
+  const aDuration = a.dur ?? 0;
+  const bDuration = b.dur ?? 0;
+  const aEndTime = aBeginTime + aDuration;
+  const bEndTime = bBeginTime + bDuration;
+  const timeDifference = compareBeginAndEnd(aBeginTime, bBeginTime, aEndTime, bEndTime);
+  if (timeDifference) {
+    return timeDifference;
+  }
+
   // If times are equal, prioritize profile calls over trace events,
   // since an exactly equal timestamp with a trace event is likely
   // indicates that the SamplesIntegrator meant to parent the trace
@@ -180,6 +187,30 @@ export function mergeEventsInOrder<T1 extends Types.Events.Event, T2 extends Typ
   return result;
 }
 
+export function parseDevtoolsDetails(timingDetail: string, key: string): Types.Extensions.ExtensionDataPayload|
+    Types.Extensions.ExtensionTrackEntryPayloadDeeplink|null {
+  try {
+    // Attempt to parse the detail as an object that might be coming from a
+    // DevTools Perf extension.
+    // Wrapped in a try-catch because timingDetail might either:
+    // 1. Not be `json.parse`-able (it should, but just in case...)
+    // 2. Not be an object - in which case the `in` check will error.
+    // If we hit either of these cases, we just ignore this mark and move on.
+    const detailObj = JSON.parse(timingDetail);
+    if (!(key in detailObj)) {
+      return null;
+    }
+    if (!Types.Extensions.isValidExtensionPayload(detailObj[key])) {
+      return null;
+    }
+    return detailObj[key];
+  } catch {
+    // No need to worry about this error, just discard this event and don't
+    // treat it as having any useful information for the purposes of extensions.
+    return null;
+  }
+}
+
 export function getNavigationForTraceEvent(
     event: Types.Events.Event,
     eventFrameId: string,
@@ -263,7 +294,7 @@ export function makeProfileCall(
  * if provided, though currently only coming from Animations. Traces may contain multiple instant events so we need to
  * account for that.
  *
- * @returns {Map<string, MatchingPairableAsyncEvents>} Map of the animation's ID to it's matching events.
+ * @returns Map of the animation's ID to it's matching events.
  */
 export function matchEvents(unpairedEvents: Types.Events.PairableAsync[]): Map<string, MatchingPairableAsyncEvents> {
   // map to store begin and end of the event
@@ -524,16 +555,13 @@ 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 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?
-    return true;
-  }
   return event.cat.includes(DevToolsTimelineEventCategory) && event.name === Types.Events.Name.RUN_TASK;
 }
 
+export function isExtensionUrl(url: string): boolean {
+  return url.startsWith('extensions:') || url.startsWith('chrome-extension:');
+}
+
 function topLevelEventIndexEndingAfter(events: Types.Events.Event[], time: Types.Timing.Micro): number {
   let index = Platform.ArrayUtilities.upperBound(events, time, (time, event) => time - event.ts) - 1;
   while (index > 0 && !isTopLevelEvent(events[index])) {

package/front_end/models/trace/helpers/TreeHelpers.test.ts

@@ -211,7 +211,6 @@ describe('TreeHelpers', () => {
       const nodeE = [...tree.roots].at(1);
       if (!nodeA || !nodeE) {
         assert(false, 'Root nodes were not found');
-        return;
       }
       const taskA = nodeA.entry;
       const taskE = nodeE.entry;
@@ -219,7 +218,6 @@ describe('TreeHelpers', () => {
       const nodeB = [...nodeA.children].at(0);
       if (!nodeB || !nodeD) {
         assert(false, 'Child nodes were not found');
-        return;
       }
       const taskD = nodeD.entry;
       const taskB = nodeB.entry;
@@ -228,14 +226,12 @@ describe('TreeHelpers', () => {
 
       if (!nodeC) {
         assert(false, 'Child nodes were not found');
-        return;
       }
       const taskC = nodeC.entry;
 
       const taskCTotalTime = taskC.dur;
       if (taskCTotalTime === undefined) {
         assert.fail('Total time for task was not found');
-        return;
       }
       assert.strictEqual(taskCTotalTime, Trace.Types.Timing.Micro(1));
       assert.strictEqual(nodeC.selfTime, taskCTotalTime);
@@ -243,7 +239,6 @@ describe('TreeHelpers', () => {
       const taskBTotalTime = taskB.dur;
       if (taskBTotalTime === undefined) {
         assert.fail('Total time for task was not found');
-        return;
       }
       assert.strictEqual(taskBTotalTime, Trace.Types.Timing.Micro(3));
       assert.strictEqual(nodeB.selfTime, Trace.Types.Timing.Micro(taskBTotalTime - taskCTotalTime));
@@ -251,7 +246,6 @@ describe('TreeHelpers', () => {
       const taskDTotalTime = taskD.dur;
       if (taskDTotalTime === undefined) {
         assert.fail('Total time for task was not found');
-        return;
       }
       assert.strictEqual(taskDTotalTime, Trace.Types.Timing.Micro(3));
       assert.strictEqual(nodeD.selfTime, taskDTotalTime);
@@ -259,7 +253,6 @@ describe('TreeHelpers', () => {
       const taskATotalTime = taskA.dur;
       if (taskATotalTime === undefined) {
         assert.fail('Total time for task was not found');
-        return;
       }
       assert.strictEqual(taskATotalTime, Trace.Types.Timing.Micro(10));
       assert.strictEqual(nodeA.selfTime, Trace.Types.Timing.Micro(taskATotalTime - taskBTotalTime - taskDTotalTime));
@@ -267,7 +260,6 @@ describe('TreeHelpers', () => {
       const taskETotalTime = taskE.dur;
       if (taskETotalTime === undefined) {
         assert.fail('Total time for task was not found');
-        return;
       }
       assert.strictEqual(taskETotalTime, Trace.Types.Timing.Micro(3));
       assert.strictEqual(nodeD.selfTime, taskETotalTime);

package/front_end/models/trace/helpers/TreeHelpers.ts

@@ -56,7 +56,7 @@ export type TraceEntryNodeId = Platform.Brand.Brand<number, 'traceEntryNodeIdTag
  *
  * Complexity: O(n), where n = number of events
  */
-export function treify(entries: Types.Events.Event[], options?: {
+export function treify(entries: readonly Types.Events.Event[], options?: {
   filter: {has: (name: Types.Events.Name) => boolean},
 }): {tree: TraceEntryTree, entryToNode: Map<Types.Events.Event, TraceEntryNode>} {
   // As we construct the tree, store a map of each entry to its node. This

package/front_end/models/trace/insights/CLSCulprits.test.ts

@@ -133,15 +133,18 @@ describeWithEnvironment('CLSCulprits', function() {
         assert.strictEqual(shifts.size, 3);
 
         const shift1 = Array.from(shifts)[0][0];
-        const shiftIframes = shifts.get(shift1)?.iframeIds;
+        const shiftIframes = shifts.get(shift1)?.iframes;
         assert.exists(shiftIframes);
         assert.lengthOf(shiftIframes, 1);
 
         const iframe = shiftIframes[0];
 
+        assert.strictEqual(iframe.frame, '36E9367B04D158F1DC34D4E46B5A124C');
+        assert.strictEqual(iframe.url, 'http://localhost:10200/simple-page.html');
+
         // Find the event with the matching frame id to make sure we got the right id.
         const dlEvent = data.LayoutShifts.domLoadingEvents.find(e => {
-          return e.args.frame === iframe;
+          return e.args.frame === iframe.frame;
         });
         assert.exists(dlEvent);
 
@@ -149,9 +152,9 @@ describeWithEnvironment('CLSCulprits', function() {
         assert.isTrue(dlEvent.ts < shift1.ts && dlEvent.ts >= shift1.ts - INVALIDATION_WINDOW);
         // Other shifts should not have iframe root causes.
         const shift2 = Array.from(shifts)[1][0];
-        assert.isEmpty(shifts.get(shift2)?.iframeIds);
+        assert.isEmpty(shifts.get(shift2)?.iframes);
         const shift3 = Array.from(shifts)[2][0];
-        assert.isEmpty(shifts.get(shift3)?.iframeIds);
+        assert.isEmpty(shifts.get(shift3)?.iframes);
       });
 
       it('handles potential font root cause correctly', async function() {
@@ -170,7 +173,7 @@ describeWithEnvironment('CLSCulprits', function() {
         assert.isOk(shift2);
         const shiftEvent = shift2[0];
 
-        const shiftFonts = shift2[1].fontRequests;
+        const shiftFonts = shift2[1].webFonts;
         assert.exists(shiftFonts);
         assert.lengthOf(shiftFonts, 1);
 
@@ -182,11 +185,11 @@ describeWithEnvironment('CLSCulprits', function() {
         // Other shifts should not have font root causes.
         const shift1 = layoutShiftEvents.at(0);
         assert.isOk(shift1);
-        assert.isEmpty(shift1[1].fontRequests);
+        assert.isEmpty(shift1[1].webFonts);
 
         const shift3 = layoutShiftEvents.at(2);
         assert.isOk(shift3);
-        assert.isEmpty(shift3[1].fontRequests);
+        assert.isEmpty(shift3[1].webFonts);
       });
 
       it('handles potential unsized images root cause correctly', async function() {