chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

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

@@ -41,7 +41,7 @@ describeWithEnvironment('Trace helpers', function() {
         name: 'process_name',
         tid,
         pid,
-        ts: Trace.Types.Timing.MicroSeconds(0),
+        ts: Trace.Types.Timing.Micro(0),
         cat: 'test',
         ph: Trace.Types.Events.Phase.METADATA,
       };
@@ -81,8 +81,8 @@ describeWithEnvironment('Trace helpers', function() {
   describe('sortTraceEventsInPlace', () => {
     function makeFakeEvent(ts: number, dur: number): Trace.Types.Events.Event {
       return {
-        ts: Trace.Types.Timing.MicroSeconds(ts),
-        dur: Trace.Types.Timing.MicroSeconds(dur),
+        ts: Trace.Types.Timing.Micro(ts),
+        dur: Trace.Types.Timing.Micro(dur),
       } as unknown as Trace.Types.Events.Event;
     }
 
@@ -117,7 +117,7 @@ describeWithEnvironment('Trace helpers', function() {
       const request2 = NetworkRequests.byTime[1];
       const navigationForSecondRequest =
           Trace.Helpers.Trace.getNavigationForTraceEvent(request2, request2.args.data.frame, Meta.navigationsByFrameId);
-      assert.strictEqual(navigationForSecondRequest?.ts, Trace.Types.Timing.MicroSeconds(636471400029));
+      assert.strictEqual(navigationForSecondRequest?.ts, Trace.Types.Timing.Micro(636471400029));
     });
 
     it('returns the correct navigation for a page load event', async function() {
@@ -375,10 +375,10 @@ describeWithEnvironment('Trace helpers', function() {
       const {parsedTrace} = await TraceLoader.traceEngine(this, 'simple-js-program.json.gz');
       const frameId = '1F729458403A23CF1D8D246095129AC4';
       const firstURL = Trace.Helpers.Trace.activeURLForFrameAtTime(
-          frameId, Trace.Types.Timing.MicroSeconds(251126654355), parsedTrace.Meta.rendererProcessesByFrame);
+          frameId, Trace.Types.Timing.Micro(251126654355), parsedTrace.Meta.rendererProcessesByFrame);
       assert.strictEqual(firstURL, 'about:blank');
       const secondURL = Trace.Helpers.Trace.activeURLForFrameAtTime(
-          frameId, Trace.Types.Timing.MicroSeconds(251126663398), parsedTrace.Meta.rendererProcessesByFrame);
+          frameId, Trace.Types.Timing.Micro(251126663398), parsedTrace.Meta.rendererProcessesByFrame);
       assert.strictEqual(secondURL, 'https://www.google.com');
     });
   });
@@ -444,7 +444,7 @@ describeWithEnvironment('Trace helpers', function() {
             {compositeFailed: 8224, unsupportedProperties: ['font-size']},
           ],
         ]);
-        // Ensure we have the correct numner of synthetic events created.
+        // Ensure we have the correct number of synthetic events created.
         assert.deepEqual(wantPairs.size, animationSynthEvents.length);
 
         animationSynthEvents.forEach(event => {
@@ -484,8 +484,8 @@ describeWithEnvironment('Trace helpers', function() {
         name: Trace.Types.Events.Name.FUNCTION_CALL,
         ph: Trace.Types.Events.Phase.COMPLETE,
         cat: 'devtools-timeline',
-        dur: Trace.Types.Timing.MicroSeconds(100),
-        ts: Trace.Types.Timing.MicroSeconds(100),
+        dur: Trace.Types.Timing.Micro(100),
+        ts: Trace.Types.Timing.Micro(100),
         pid: Trace.Types.Events.ProcessID(1),
         tid: Trace.Types.Events.ThreadID(1),
         args: {
@@ -551,7 +551,7 @@ describeWithEnvironment('Trace helpers', function() {
       const filteredByEndTimeEvents = Trace.Helpers.Trace.findUpdateLayoutTreeEvents(
           mainThread.entries,
           parsedTrace.Meta.traceBounds.min,
-          Trace.Types.Timing.MicroSeconds(lastEvent.ts - 1_000),
+          Trace.Types.Timing.Micro(lastEvent.ts - 1_000),
       );
       assert.lengthOf(filteredByEndTimeEvents, 10);
     });
@@ -607,8 +607,8 @@ describeWithEnvironment('Trace helpers', function() {
       Trace.Helpers.Trace.forEachEvent(traceEvents, {
         onEndEvent,
         onStartEvent,
-        startTime: Trace.Types.Timing.MicroSeconds(5),
-        endTime: Trace.Types.Timing.MicroSeconds(9),
+        startTime: Trace.Types.Timing.Micro(5),
+        endTime: Trace.Types.Timing.Micro(9),
       });
       const eventsFromStartEventCalls = onStartEvent.getCalls().map(a => a.args[0]);
       const eventsFromEndEventCalls = onEndEvent.getCalls().map(a => a.args[0]);
@@ -732,7 +732,7 @@ describeWithEnvironment('Trace helpers', function() {
   describe('findNextEventAfterTimestamp', () => {
     it('gets the first screenshot after a trace', async function() {
       const {parsedTrace} = await TraceLoader.traceEngine(this, 'cls-multiple-frames.json.gz');
-      const screenshots = parsedTrace.Screenshots.all;
+      const screenshots = parsedTrace.Screenshots.legacySyntheticScreenshots ?? [];
       const {clusters} = parsedTrace.LayoutShifts;
       const shifts = clusters.flatMap(cluster => cluster.events);
       assert.isAtLeast(shifts.length, 10);

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

@@ -11,11 +11,11 @@ import * as Types from '../types/types.js';
 import {SyntheticEventsManager} from './SyntheticEvents.js';
 import {eventTimingsMicroSeconds} from './Timing.js';
 
-type MatchingPairableAsyncEvents = {
-  begin: Types.Events.PairableAsyncBegin|null,
-  end: Types.Events.PairableAsyncEnd|null,
-  instant?: Types.Events.PairableAsyncInstant[],
-};
+interface MatchingPairableAsyncEvents {
+  begin: Types.Events.PairableAsyncBegin|null;
+  end: Types.Events.PairableAsyncEnd|null;
+  instant?: Types.Events.PairableAsyncInstant[];
+}
 
 /**
  * Extracts the raw stack trace in known trace events. Most likely than
@@ -109,10 +109,10 @@ export function addEventToProcessThread<T extends Types.Events.Event>(
   eventsInProcessThread.set(event.pid, eventsInThread);
 }
 
-export type TimeSpan = {
-  ts: Types.Timing.MicroSeconds,
-  dur?: Types.Timing.MicroSeconds,
-};
+export interface TimeSpan {
+  ts: Types.Timing.Micro;
+  dur?: Types.Timing.Micro;
+}
 export function eventTimeComparator(a: TimeSpan, b: TimeSpan): -1|0|1 {
   const aBeginTime = a.ts;
   const bBeginTime = b.ts;
@@ -138,8 +138,7 @@ export function eventTimeComparator(a: TimeSpan, b: TimeSpan): -1|0|1 {
  * Sorts all the events in place, in order, by their start time. If they have
  * the same start time, orders them by longest first.
  */
-export function sortTraceEventsInPlace(events: {ts: Types.Timing.MicroSeconds, dur?: Types.Timing.MicroSeconds}[]):
-    void {
+export function sortTraceEventsInPlace(events: {ts: Types.Timing.Micro, dur?: Types.Timing.Micro}[]): void {
   events.sort(eventTimeComparator);
 }
 
@@ -202,10 +201,10 @@ export function extractId(event: Types.Events.PairableAsync|
 }
 
 export function activeURLForFrameAtTime(
-    frameId: string, time: Types.Timing.MicroSeconds,
-    rendererProcessesByFrame: Map<
-        string,
-        Map<Types.Events.ProcessID, {frame: Types.Events.TraceFrame, window: Types.Timing.TraceWindowMicroSeconds}[]>>):
+    frameId: string, time: Types.Timing.Micro,
+    rendererProcessesByFrame:
+        Map<string,
+            Map<Types.Events.ProcessID, {frame: Types.Events.TraceFrame, window: Types.Timing.TraceWindowMicro}[]>>):
     string|null {
   const processData = rendererProcessesByFrame.get(frameId);
   if (!processData) {
@@ -234,7 +233,7 @@ export function activeURLForFrameAtTime(
  */
 export function makeProfileCall(
     node: CPUProfile.ProfileTreeModel.ProfileNode, profileId: Types.Events.ProfileID, sampleIndex: number,
-    ts: Types.Timing.MicroSeconds, pid: Types.Events.ProcessID,
+    ts: Types.Timing.Micro, pid: Types.Events.ProcessID,
     tid: Types.Events.ThreadID): Types.Events.SyntheticProfileCall {
   return {
     cat: '',
@@ -245,7 +244,7 @@ export function makeProfileCall(
     pid,
     tid,
     ts,
-    dur: Types.Timing.MicroSeconds(0),
+    dur: Types.Timing.Micro(0),
     callFrame: node.callFrame,
     sampleIndex,
     profileId,
@@ -348,7 +347,7 @@ export function createSortedSyntheticEvents<T extends Types.Events.PairableAsync
       // Both events have the same name, so it doesn't matter which we pick to
       // use as the description
       name: beginEvent.name,
-      dur: Types.Timing.MicroSeconds(targetEvent.ts - beginEvent.ts),
+      dur: Types.Timing.Micro(targetEvent.ts - beginEvent.ts),
       ts: beginEvent.ts,
       args: {
         data: triplet,
@@ -520,7 +519,7 @@ export function isTopLevelEvent(event: Types.Events.Event): boolean {
   return event.cat.includes(DevToolsTimelineEventCategory) && event.name === Types.Events.Name.RUN_TASK;
 }
 
-function topLevelEventIndexEndingAfter(events: Types.Events.Event[], time: Types.Timing.MicroSeconds): number {
+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])) {
     index--;
@@ -528,8 +527,8 @@ function topLevelEventIndexEndingAfter(events: Types.Events.Event[], time: Types
   return Math.max(index, 0);
 }
 export function findUpdateLayoutTreeEvents(
-    events: Types.Events.Event[], startTime: Types.Timing.MicroSeconds,
-    endTime?: Types.Timing.MicroSeconds): Types.Events.UpdateLayoutTree[] {
+    events: Types.Events.Event[], startTime: Types.Timing.Micro,
+    endTime?: Types.Timing.Micro): Types.Events.UpdateLayoutTree[] {
   const foundEvents: Types.Events.UpdateLayoutTree[] = [];
   const startEventIndex = topLevelEventIndexEndingAfter(events, startTime);
   for (let i = startEventIndex; i < events.length; i++) {
@@ -545,14 +544,14 @@ export function findUpdateLayoutTreeEvents(
   return foundEvents;
 }
 
-export function findNextEventAfterTimestamp<T extends Types.Events.Event>(
-    candidates: T[], ts: Types.Timing.MicroSeconds): T|null {
+export function findNextEventAfterTimestamp<T extends Types.Events.Event>(candidates: T[], ts: Types.Timing.Micro): T|
+    null {
   const index = Platform.ArrayUtilities.nearestIndexFromBeginning(candidates, candidate => ts < candidate.ts);
   return index === null ? null : candidates[index];
 }
 
 export function findPreviousEventBeforeTimestamp<T extends Types.Events.Event>(
-    candidates: T[], ts: Types.Timing.MicroSeconds): T|null {
+    candidates: T[], ts: Types.Timing.Micro): T|null {
   const index = Platform.ArrayUtilities.nearestIndexFromEnd(candidates, candidate => candidate.ts < ts);
   return index === null ? null : candidates[index];
 }
@@ -562,8 +561,8 @@ export interface ForEachEventConfig {
   onEndEvent: (event: Types.Events.Event) => void;
   onInstantEvent?: (event: Types.Events.Event) => void;
   eventFilter?: (event: Types.Events.Event) => boolean;
-  startTime?: Types.Timing.MicroSeconds;
-  endTime?: Types.Timing.MicroSeconds;
+  startTime?: Types.Timing.Micro;
+  endTime?: Types.Timing.Micro;
   /* If async events should be skipped. Defaults to true */
   ignoreAsyncEvents?: boolean;
 }
@@ -596,14 +595,14 @@ export interface ForEachEventConfig {
  * 9. End A
  *
  * By default, async events are skipped. This behaviour can be
- * overriden making use of the config.ignoreAsyncEvents parameter.
+ * overridden making use of the config.ignoreAsyncEvents parameter.
  */
 export function forEachEvent(
     events: Types.Events.Event[],
     config: ForEachEventConfig,
     ): void {
-  const globalStartTime = config.startTime ?? Types.Timing.MicroSeconds(0);
-  const globalEndTime = config.endTime || Types.Timing.MicroSeconds(Infinity);
+  const globalStartTime = config.startTime ?? Types.Timing.Micro(0);
+  const globalEndTime = config.endTime || Types.Timing.Micro(Infinity);
   const ignoreAsyncEvents = config.ignoreAsyncEvents === false ? false : true;
 
   const stack: Types.Events.Event[] = [];
@@ -670,11 +669,6 @@ export function eventHasCategory(event: Types.Events.Event, category: string): b
   return parsedCategoriesForEvent.has(category);
 }
 
-export function nodeIdForInvalidationEvent(event: Types.Events.InvalidationTrackingEvent): Protocol.DOM.BackendNodeId|
-    null {
-  return event.args.data.nodeId ?? null;
-}
-
 /**
  * This compares Types.Events.CallFrame with Protocol.Runtime.CallFrame and checks for equality.
  */
@@ -685,6 +679,13 @@ export function isMatchingCallFrame(
       eventFrame.functionName === nodeFrame.functionName;
 }
 
-export function eventContainsTimestamp(event: Types.Events.Event, ts: Types.Timing.MicroSeconds): boolean {
+export function eventContainsTimestamp(event: Types.Events.Event, ts: Types.Timing.Micro): boolean {
   return event.ts <= ts && event.ts + (event.dur || 0) >= ts;
 }
+
+export function extractSampleTraceId(event: Types.Events.Event): number|null {
+  if (Types.Events.isConsoleRunTask(event) || Types.Events.isConsoleTimeStamp(event)) {
+    return event.args?.data?.sampleTraceId || null;
+  }
+  return null;
+}

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

@@ -237,7 +237,7 @@ describe('TreeHelpers', () => {
         assert.fail('Total time for task was not found');
         return;
       }
-      assert.strictEqual(taskCTotalTime, Trace.Types.Timing.MicroSeconds(1));
+      assert.strictEqual(taskCTotalTime, Trace.Types.Timing.Micro(1));
       assert.strictEqual(nodeC.selfTime, taskCTotalTime);
 
       const taskBTotalTime = taskB.dur;
@@ -245,15 +245,15 @@ describe('TreeHelpers', () => {
         assert.fail('Total time for task was not found');
         return;
       }
-      assert.strictEqual(taskBTotalTime, Trace.Types.Timing.MicroSeconds(3));
-      assert.strictEqual(nodeB.selfTime, Trace.Types.Timing.MicroSeconds(taskBTotalTime - taskCTotalTime));
+      assert.strictEqual(taskBTotalTime, Trace.Types.Timing.Micro(3));
+      assert.strictEqual(nodeB.selfTime, Trace.Types.Timing.Micro(taskBTotalTime - taskCTotalTime));
 
       const taskDTotalTime = taskD.dur;
       if (taskDTotalTime === undefined) {
         assert.fail('Total time for task was not found');
         return;
       }
-      assert.strictEqual(taskDTotalTime, Trace.Types.Timing.MicroSeconds(3));
+      assert.strictEqual(taskDTotalTime, Trace.Types.Timing.Micro(3));
       assert.strictEqual(nodeD.selfTime, taskDTotalTime);
 
       const taskATotalTime = taskA.dur;
@@ -261,16 +261,15 @@ describe('TreeHelpers', () => {
         assert.fail('Total time for task was not found');
         return;
       }
-      assert.strictEqual(taskATotalTime, Trace.Types.Timing.MicroSeconds(10));
-      assert.strictEqual(
-          nodeA.selfTime, Trace.Types.Timing.MicroSeconds(taskATotalTime - taskBTotalTime - taskDTotalTime));
+      assert.strictEqual(taskATotalTime, Trace.Types.Timing.Micro(10));
+      assert.strictEqual(nodeA.selfTime, Trace.Types.Timing.Micro(taskATotalTime - taskBTotalTime - taskDTotalTime));
 
       const taskETotalTime = taskE.dur;
       if (taskETotalTime === undefined) {
         assert.fail('Total time for task was not found');
         return;
       }
-      assert.strictEqual(taskETotalTime, Trace.Types.Timing.MicroSeconds(3));
+      assert.strictEqual(taskETotalTime, Trace.Types.Timing.Micro(3));
       assert.strictEqual(nodeD.selfTime, taskETotalTime);
     });
     describe('building hierarchies trace events and profile calls', () => {
@@ -372,9 +371,9 @@ describe('TreeHelpers', () => {
         callOrder.push({type: 'END', entryName: entry.name});
       }
       Trace.Helpers.TreeHelpers.walkEntireTree(entryToNode, tree, onEntryStart, onEntryEnd, {
-        min: Trace.Types.Timing.MicroSeconds(5),
-        max: Trace.Types.Timing.MicroSeconds(10),
-        range: Trace.Types.Timing.MicroSeconds(5),
+        min: Trace.Types.Timing.Micro(5),
+        max: Trace.Types.Timing.Micro(10),
+        range: Trace.Types.Timing.Micro(5),
       });
 
       assert.deepEqual(callOrder, [
@@ -455,74 +454,4 @@ describe('TreeHelpers', () => {
          assert.isFalse(Trace.Helpers.TreeHelpers.canBuildTreesFromEvents(data));
        });
   });
-  describe('buildTreesFromEventsForAI', () => {
-    it('returns the trace entry tree starting from the root task, highlighting the selected event', () => {
-      const evaluateScript = makeCompleteEvent(Trace.Types.Events.Name.EVALUATE_SCRIPT, 0, 500);
-      const v8Run = makeCompleteEvent('v8.run', 10, 490);
-      const parseFunction = makeCompleteEvent('V8.ParseFunction', 12, 1);
-
-      const traceEvents: Trace.Types.Events.Event[] = [evaluateScript, v8Run, parseFunction];
-      const profileCalls = [makeProfileCall('a', 100, 200), makeProfileCall('b', 300, 200)];
-
-      // Roughly this looks like:
-      // 0                                          500
-      // |------------- EvaluateScript -------------|
-      //  |-        v8.run                         -|
-      //    |--|   |-    a   -||-          b        |
-      //      ^ V8.ParseFunction
-
-      const allEntries = Trace.Helpers.Trace.mergeEventsInOrder(traceEvents, profileCalls);
-      const {tree, entryToNode} = Trace.Helpers.TreeHelpers.treify(allEntries, {filter: {has: () => true}});
-      const rootNode = entryToNode.get(evaluateScript);
-      // Select something from the middle.
-      const selectedNode = entryToNode.get(v8Run);
-
-      assert.strictEqual(tree.roots.size, 1);
-      assert.exists(rootNode);
-      assert.exists(selectedNode);
-
-      const aiNodeTree = Trace.Helpers.TreeHelpers.AINode.fromEntryNode(selectedNode, () => true);
-      const v8RunNode = Trace.Helpers.TreeHelpers.AINode.getSelectedNodeWithinTree(aiNodeTree);
-
-      assert.exists(aiNodeTree);
-      assert.exists(v8RunNode);
-
-      // First check the serialization as a while.
-      assert.deepEqual(JSON.parse(JSON.stringify(aiNodeTree)), {
-        name: 'EvaluateScript',
-        dur: 0.5,
-        self: 0,
-        children: [{
-          selected: true,
-          name: 'v8.run',
-          dur: 0.5,
-          self: 0.1,
-          children: [
-            {name: 'V8.ParseFunction', dur: 0, self: 0},
-            {name: 'a', url: '', dur: 0.2, self: 0.2},
-            {name: 'b', url: '', dur: 0.2, self: 0.2},
-          ],
-        }],
-      });
-
-      // Now we can make sure the pre-serialized data is also correct.
-      assert.strictEqual(v8RunNode.name, 'v8.run');
-      assert.isTrue(v8RunNode.selected);
-      assert.strictEqual(v8RunNode.duration, 0.49);
-      assert.strictEqual(v8RunNode.children?.length, 3);
-
-      assert.strictEqual(aiNodeTree.name, 'EvaluateScript');
-      assert.isUndefined(aiNodeTree.selected);
-      assert.strictEqual(aiNodeTree.duration, 0.5);
-      assert.strictEqual(aiNodeTree.children?.length, 1);
-
-      const parseFnAINode = v8RunNode.children?.at(0) as Trace.Helpers.TreeHelpers.AINode;
-      assert.exists(v8RunNode);
-
-      assert.strictEqual(parseFnAINode.name, 'V8.ParseFunction');
-      assert.isUndefined(parseFnAINode.selected);
-      assert.strictEqual(parseFnAINode.duration, 0.001);
-      assert.isUndefined(parseFnAINode.children);
-    });
-  });
 });

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

@@ -4,7 +4,7 @@
 
 import * as Types from '../types/types.js';
 
-import {eventIsInBounds, microSecondsToMilliseconds} from './Timing.js';
+import {eventIsInBounds} from './Timing.js';
 
 let nodeIdCount = 0;
 export const makeTraceEntryNodeId = (): TraceEntryNodeId => (++nodeIdCount) as TraceEntryNodeId;
@@ -31,180 +31,12 @@ export interface TraceEntryTree {
 export interface TraceEntryNode {
   entry: Types.Events.Event;
   depth: number;
-  selfTime?: Types.Timing.MicroSeconds;
+  selfTime?: Types.Timing.Micro;
   id: TraceEntryNodeId;
   parent: TraceEntryNode|null;
   children: TraceEntryNode[];
 }
 
-export interface AINodeSerialized {
-  name: string;
-  dur?: number;
-  self?: number;
-  children?: AINodeSerialized[];
-  url?: string;
-  selected?: boolean;
-}
-
-/**
- * Node in a graph simplified for AI Assistance processing. The graph mirrors the TraceEntryNode one.
- * Huge tip of the hat to Victor Porof for prototyping this with some great work: https://crrev.com/c/5711249
- */
-export class AINode {
-  // event: Types.Events.Event; // Set in the constructor.
-  name: string;
-  duration?: Types.Timing.MilliSeconds;
-  selfDuration?: Types.Timing.MilliSeconds;
-  id?: TraceEntryNodeId;
-  children?: AINode[];
-  url?: string;
-  selected?: boolean;
-
-  constructor(public event: Types.Events.Event) {
-    this.name = event.name;
-    this.duration = event.dur === undefined ? undefined : microSecondsToMilliseconds(event.dur);
-
-    if (Types.Events.isProfileCall(event)) {
-      this.name = event.callFrame.functionName || '(anonymous)';
-      this.url = event.callFrame.url;
-    }
-  }
-
-  // Manually handle how nodes in this tree are serialized. We'll drop serveral properties that we don't need in the JSON string.
-  // FYI: toJSON() is invoked implicitly via JSON.stringify()
-  toJSON(): AINodeSerialized {
-    return {
-      selected: this.selected,
-      name: this.name,
-      url: this.url,
-      // Round milliseconds because we don't need the precision
-      dur: this.duration === undefined ? undefined : Math.round(this.duration * 10) / 10,
-      self: this.selfDuration === undefined ? undefined : Math.round(this.selfDuration * 10) / 10,
-      children: this.children?.length ? this.children : undefined,
-    };
-  }
-
-  static #fromTraceEvent(event: Types.Events.Event): AINode {
-    return new AINode(event);
-  }
-
-  /**
-   * Builds a TraceEntryNodeForAI tree from a node and marks the selected node. Primary entrypoint from EntriesFilter
-   */
-  static fromEntryNode(selectedNode: TraceEntryNode, entryIsVisibleInTimeline: (event: Types.Events.Event) => boolean):
-      AINode {
-    /**
-     * Builds a AINode tree from a TraceEntryNode tree and marks the selected node.
-     */
-    function fromEntryNodeAndTree(node: TraceEntryNode): AINode {
-      const aiNode = AINode.#fromTraceEvent(node.entry);
-      aiNode.id = node.id;
-      if (node === selectedNode) {
-        aiNode.selected = true;
-      }
-      aiNode.selfDuration = node.selfTime === undefined ? undefined : microSecondsToMilliseconds(node.selfTime);
-      for (const child of node.children) {
-        aiNode.children ??= [];
-        aiNode.children.push(fromEntryNodeAndTree(child));
-      }
-      return aiNode;
-    }
-
-    function findTopMostVisibleAncestor(node: TraceEntryNode): TraceEntryNode {
-      const parentNodes = [node];
-      let parent = node.parent;
-      while (parent) {
-        parentNodes.unshift(parent);
-        parent = parent.parent;
-      }
-      return parentNodes.find(node => entryIsVisibleInTimeline(node.entry)) ?? node;
-    }
-
-    const topMostVisibleRoot = findTopMostVisibleAncestor(selectedNode);
-    const aiNode = fromEntryNodeAndTree(topMostVisibleRoot);
-
-    // If our root wasn't visible, this could return an array of multiple RunTasks.
-    // But with a visible root, we safely get back the exact same root, now with its descendent tree updated.
-    // Filter to ensure our tree here only has "visible" entries
-    const [filteredAiNodeRoot] = AINode.#filterRecursive([aiNode], node => {
-      if (node.event.name === 'V8.CompileCode' || node.event.name === 'UpdateCounters') {
-        return false;
-      }
-      return entryIsVisibleInTimeline(node.event);
-    });
-    return filteredAiNodeRoot;
-  }
-
-  static getSelectedNodeWithinTree(node: AINode): AINode|null {
-    if (node.selected) {
-      return node;
-    }
-    if (!node.children) {
-      return null;
-    }
-    for (const child of node.children) {
-      const returnedNode = AINode.getSelectedNodeWithinTree(child);
-      if (returnedNode) {
-        return returnedNode;
-      }
-    }
-    return null;
-  }
-
-  static #filterRecursive(list: AINode[], predicate: (node: AINode) => boolean): AINode[] {
-    let done;
-    do {
-      done = true;
-      const filtered: AINode[] = [];
-      for (const node of list) {
-        if (predicate(node)) {
-          // Keep it
-          filtered.push(node);
-        } else if (node.children) {
-          filtered.push(...node.children);
-          done = false;
-        }
-      }
-      list = filtered;
-    } while (!done);
-
-    for (const node of list) {
-      if (node.children) {
-        node.children = AINode.#filterRecursive(node.children, predicate);
-      }
-    }
-    return list;
-  }
-
-  static #removeInexpensiveNodesRecursively(
-      list: AINode[],
-      options?: {minDuration?: number, minSelf?: number, minJsDuration?: number, minJsSelf?: number}): AINode[] {
-    const minDuration = options?.minDuration ?? 0;
-    const minSelf = options?.minSelf ?? 0;
-    const minJsDuration = options?.minJsDuration ?? 0;
-    const minJsSelf = options?.minJsSelf ?? 0;
-
-    const isJS = (node: AINode): boolean => Boolean(node.url);
-    const longEnough = (node: AINode): boolean =>
-        node.duration === undefined || node.duration >= (isJS(node) ? minJsDuration : minDuration);
-    const selfLongEnough = (node: AINode): boolean =>
-        node.selfDuration === undefined || node.selfDuration >= (isJS(node) ? minJsSelf : minSelf);
-
-    return AINode.#filterRecursive(list, node => longEnough(node) && selfLongEnough(node));
-  }
-
-  // Invoked from PerformanceAgent
-  sanitize(): void {
-    if (this.children) {
-      this.children = AINode.#removeInexpensiveNodesRecursively(this.children, {
-        minDuration: Types.Timing.MilliSeconds(1),
-        minJsDuration: Types.Timing.MilliSeconds(1),
-        minJsSelf: Types.Timing.MilliSeconds(0.1),
-      });
-    }
-  }
-}
-
 class TraceEntryNodeIdTag {
   /* eslint-disable-next-line no-unused-private-class-members */
   readonly #tag: (symbol|undefined);
@@ -256,7 +88,7 @@ export function treify(entries: Types.Events.Event[], options?: {
     // node for it, mark it as a root, then proceed with the next event.
     if (stack.length === 0) {
       tree.roots.add(node);
-      node.selfTime = Types.Timing.MicroSeconds(duration);
+      node.selfTime = Types.Timing.Micro(duration);
       stack.push(node);
       tree.maxDepth = Math.max(tree.maxDepth, stack.length);
       entryToNode.set(event, node);
@@ -277,7 +109,7 @@ export function treify(entries: Types.Events.Event[], options?: {
     const parentEnd = parentBegin + parentDuration;
     // Check the relationship between the parent event at the top of the stack,
     // and the current event being processed. There are only 4 distinct
-    // possiblities, only 2 of them actually valid, given the assumed sorting:
+    // possibilities, only 2 of them actually valid, given the assumed sorting:
     // 1. Current event starts before the parent event, ends whenever. (invalid)
     // 2. Current event starts after the parent event, ends whenever. (valid)
     // 3. Current event starts during the parent event, ends after. (invalid)
@@ -316,9 +148,9 @@ export function treify(entries: Types.Events.Event[], options?: {
     node.depth = stack.length;
     node.parent = parentNode;
     parentNode.children.push(node);
-    node.selfTime = Types.Timing.MicroSeconds(duration);
+    node.selfTime = Types.Timing.Micro(duration);
     if (parentNode.selfTime !== undefined) {
-      parentNode.selfTime = Types.Timing.MicroSeconds(parentNode.selfTime - (event.dur || 0));
+      parentNode.selfTime = Types.Timing.Micro(parentNode.selfTime - (event.dur || 0));
     }
     stack.push(node);
     tree.maxDepth = Math.max(tree.maxDepth, stack.length);
@@ -390,8 +222,8 @@ export function walkEntireTree(
     tree: TraceEntryTree,
     onEntryStart: (entry: Types.Events.Event) => void,
     onEntryEnd: (entry: Types.Events.Event) => void,
-    traceWindowToInclude?: Types.Timing.TraceWindowMicroSeconds,
-    minDuration?: Types.Timing.MicroSeconds,
+    traceWindowToInclude?: Types.Timing.TraceWindowMicro,
+    minDuration?: Types.Timing.Micro,
     ): void {
   for (const rootNode of tree.roots) {
     walkTreeByNode(entryToNode, rootNode, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration);
@@ -403,8 +235,8 @@ function walkTreeByNode(
     rootNode: TraceEntryNode,
     onEntryStart: (entry: Types.Events.Event) => void,
     onEntryEnd: (entry: Types.Events.Event) => void,
-    traceWindowToInclude?: Types.Timing.TraceWindowMicroSeconds,
-    minDuration?: Types.Timing.MicroSeconds,
+    traceWindowToInclude?: Types.Timing.TraceWindowMicro,
+    minDuration?: Types.Timing.Micro,
     ): void {
   if (traceWindowToInclude && !treeNodeIsInWindow(rootNode, traceWindowToInclude)) {
     // If this node is not within the provided window, we can skip it. We also
@@ -414,8 +246,8 @@ function walkTreeByNode(
   }
 
   if (typeof minDuration !== 'undefined') {
-    const duration = Types.Timing.MicroSeconds(
-        rootNode.entry.ts + Types.Timing.MicroSeconds(rootNode.entry.dur ?? 0),
+    const duration = Types.Timing.Micro(
+        rootNode.entry.ts + Types.Timing.Micro(rootNode.entry.dur ?? 0),
     );
     if (duration < minDuration) {
       return;
@@ -434,7 +266,7 @@ function walkTreeByNode(
  * window. The entire node does not have to fit inside the window, but it does
  * have to partially intersect it.
  */
-function treeNodeIsInWindow(node: TraceEntryNode, traceWindow: Types.Timing.TraceWindowMicroSeconds): boolean {
+function treeNodeIsInWindow(node: TraceEntryNode, traceWindow: Types.Timing.TraceWindowMicro): boolean {
   return eventIsInBounds(node.entry, traceWindow);
 }
 

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

@@ -10,7 +10,7 @@ import * as Types from '../types/types.js';
 import {Models} from './insights.js';
 
 // Root cause invalidation window.
-const INVALIDATION_WINDOW = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(0.5));
+const INVALIDATION_WINDOW = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(0.5));
 
 describeWithEnvironment('CLSCulprits', function() {
   describe('non composited animations', function() {