chrome-devtools-frontend 1.0.1367881 → 1.0.1376716

package/front_end/panels/timeline/utils/AICallTree.ts

@@ -0,0 +1,165 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as TimelineModel from '../../../models/timeline_model/timeline_model.js';
+import * as Trace from '../../../models/trace/trace.js';
+
+import {nameForEntry} from './EntryName.js';
+import {visibleTypes} from './EntryStyles.js';
+import {SourceMapsResolver} from './SourceMapsResolver.js';
+
+/** Iterates from a node down through its descendents. If the callback returns true, the loop stops. */
+function depthFirstWalk(
+    nodes: MapIterator<TimelineModel.TimelineProfileTree.Node>,
+    callback: (arg0: TimelineModel.TimelineProfileTree.Node) => void|true): void {
+  for (const node of nodes) {
+    if (callback?.(node)) {
+      break;
+    }
+    depthFirstWalk(node.children().values(), callback);  // Go deeper.
+  }
+}
+
+export class AICallTree {
+  constructor(
+      public selectedNode: TimelineModel.TimelineProfileTree.Node,
+      public rootNode: TimelineModel.TimelineProfileTree.TopDownRootNode,
+      // TODO: see if we can avoid passing around this entire thing.
+      public parsedTrace: Trace.Handlers.Types.ParsedTrace,
+  ) {
+  }
+
+  static from(
+      selectedEvent: Trace.Types.Events.Event, events: Trace.Types.Events.Event[],
+      parsedTrace: Trace.Handlers.Types.ParsedTrace): AICallTree {
+    const timings = Trace.Helpers.Timing.eventTimingsMilliSeconds(selectedEvent);
+    const selectedEventBounds = Trace.Helpers.Timing.traceWindowFromMicroSeconds(
+        Trace.Helpers.Timing.millisecondsToMicroseconds(timings.startTime),
+        Trace.Helpers.Timing.millisecondsToMicroseconds(timings.endTime));
+
+    const threadEvents = parsedTrace.Renderer.processes.get(selectedEvent.pid)?.threads.get(selectedEvent.tid)?.entries;
+    if (!threadEvents) {
+      throw new Error('Cannot locate thread');
+    }
+    const overlappingEvents = threadEvents.filter(e => Trace.Helpers.Timing.eventIsInBounds(e, selectedEventBounds));
+
+    const visibleEventsFilter = new TimelineModel.TimelineModelFilter.TimelineVisibleEventsFilter(visibleTypes());
+    const customFilter = new AITreeFilter(timings.duration);
+    // Build a tree bounded by the selected event's timestamps, and our other filters applied
+    const rootNode = new TimelineModel.TimelineProfileTree.TopDownRootNode(
+        overlappingEvents, [visibleEventsFilter, customFilter], timings.startTime, timings.endTime, false, null);
+
+    // Walk the tree to find selectedNode
+    let selectedNode: TimelineModel.TimelineProfileTree.Node|null = null;
+    depthFirstWalk([rootNode].values(), node => {
+      if (node.event === selectedEvent) {
+        selectedNode = node;
+        return true;
+      }
+      return;
+    });
+
+    if (selectedNode === null) {
+      throw new Error('Node not within its own tree. Unexpected.');
+    }
+    const instance = new AICallTree(selectedNode, rootNode, parsedTrace);
+    // instance.logDebug();
+    return instance;
+  }
+
+  /** Define precisely how the call tree is serialized. Typically called from within `DrJonesPerformanceAgent` */
+  serialize(): string {
+    const nodeToIdMap = new Map<TimelineModel.TimelineProfileTree.Node, number>();
+    // Keep a map of URLs. We'll output a LUT to keep size down.
+    const allUrls: string[] = [];
+
+    let nodesStr = '';
+    depthFirstWalk(this.rootNode.children().values(), node => {
+      nodesStr += AICallTree.stringifyNode(node, this.parsedTrace, this.selectedNode, nodeToIdMap, allUrls);
+    });
+
+    let output = '';
+    if (allUrls.length) {
+      // Output lookup table of URLs within this tree
+      output += '\n# All URL #s:\n\n' + allUrls.map((url, index) => `  * ${index}: ${url}`).join('\n');
+    }
+    output += '\n\n# Call tree:' + nodesStr;
+    return output;
+  }
+
+  /* This custom YAML-like format with an adjacency list for children is 35% more token efficient than JSON */
+  static stringifyNode(
+      node: TimelineModel.TimelineProfileTree.Node, parsedTrace: Trace.Handlers.Types.ParsedTrace,
+      selectedNode: TimelineModel.TimelineProfileTree.Node,
+      nodeToIdMap: Map<TimelineModel.TimelineProfileTree.Node, number>, allUrls: string[]): string {
+    const event = node.event;
+    if (!event) {
+      throw new Error('Event required');
+    }
+
+    const url = SourceMapsResolver.resolvedURLForEntry(parsedTrace, event);
+    // Get the index of the URL within allUrls, and push if needed. Set to -1 if there's no URL here.
+    const urlIndex = !url ? -1 : allUrls.indexOf(url) === -1 ? allUrls.push(url) - 1 : allUrls.indexOf(url);
+    const children = Array.from(node.children().values());
+
+    // Identifier string includes an id and name:
+    //   eg "[13] Parse HTML" or "[45] parseCPUProfileFormatFromFile"
+    const getIdentifier = (node: TimelineModel.TimelineProfileTree.Node): string => {
+      if (!node.event || typeof node.id !== 'string') {
+        throw new Error('ok');
+      }
+      if (!nodeToIdMap.has(node)) {
+        nodeToIdMap.set(node, nodeToIdMap.size + 1);
+      }
+      return `${nodeToIdMap.get(node)} – ${nameForEntry(node.event, parsedTrace)}`;
+    };
+
+    // Round milliseconds because we don't need the precision
+    const roundToTenths = (num: number): number => Math.round(num * 10) / 10;
+
+    // Build a multiline string describing this callframe node
+    const lines = [
+      `\n\nNode: ${getIdentifier(node)}`,
+      selectedNode === node && 'Selected: true',
+      node.totalTime && `dur: ${roundToTenths(node.totalTime)}`,
+      // node.functionSource && `snippet: ${node.functionSource.slice(0, 250)}`,
+      node.selfTime && `self: ${roundToTenths(node.selfTime)}`,
+      urlIndex !== -1 && `URL #: ${urlIndex}`,
+    ];
+    if (children.length) {
+      lines.push('Children:');
+      lines.push(...children.map(node => `  * ${getIdentifier(node)}`));
+    }
+    return lines.filter(Boolean).join('\n');
+  }
+
+  // Only used for debugging.
+  logDebug(): void {
+    const str = this.serialize();
+    // eslint-disable-next-line no-console
+    console.log('🎆', str);
+    if (str.length > 45_000) {
+      // Manual testing shows 45k fits. 50k doesnt.
+      // Max is 32k _tokens_, but tokens to bytes is wishywashy, so... hard to know for sure.
+      console.warn('Output will likely not fit in the context window. Expect an AIDA error.');
+    }
+  }
+}
+
+export class AITreeFilter extends TimelineModel.TimelineModelFilter.TimelineModelFilter {
+  #minDuration: Trace.Types.Timing.MicroSeconds;
+  constructor(eventDuration: Trace.Types.Timing.MilliSeconds) {
+    super();
+    // The larger the selected event is, the less small ones matter. We'll exclude items under ½% of the selected event's size
+    // We'll always exclude items under 0.15ms of total time.
+    const minDurationMs = Math.max(Trace.Types.Timing.MilliSeconds(0.15), eventDuration * 0.005);
+    this.#minDuration = Trace.Helpers.Timing.millisecondsToMicroseconds(Trace.Types.Timing.MilliSeconds(minDurationMs));
+  }
+  accept(event: Trace.Types.Events.Event): boolean {
+    if (event.name === Trace.Types.Events.Name.COMPILE_CODE) {
+      return false;
+    }
+    return event.dur ? event.dur >= this.#minDuration : false;
+  }
+}

package/front_end/panels/timeline/{components → utils}/EntryName.test.ts

@@ -8,14 +8,14 @@ import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
 import {getMainThread} from '../../../testing/TraceHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 
-import * as Components from './components.js';
+import * as Utils from './utils.js';
 
 describeWithEnvironment('EntryName', () => {
   it('uses the URL for the name of a network request', async function() {
     const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
     const request = parsedTrace.NetworkRequests.byTime.at(0);
     assert.isOk(request);
-    const name = Components.EntryName.nameForEntry(request);
+    const name = Utils.EntryName.nameForEntry(request);
     assert.strictEqual(name, 'web.dev/ (web.dev)');
   });
 
@@ -23,7 +23,7 @@ describeWithEnvironment('EntryName', () => {
     const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
     const frame = parsedTrace.Frames.frames.at(0);
     assert.isOk(frame);
-    const name = Components.EntryName.nameForEntry(frame);
+    const name = Utils.EntryName.nameForEntry(frame);
     assert.strictEqual(name, 'Frame');
   });
 
@@ -33,7 +33,7 @@ describeWithEnvironment('EntryName', () => {
       return Trace.Types.Events.isDispatch(event) && event.args.data.type === 'click';
     });
     assert.isOk(clickEvent);
-    const name = Components.EntryName.nameForEntry(clickEvent);
+    const name = Utils.EntryName.nameForEntry(clickEvent);
     assert.strictEqual(name, 'Event: click');
   });
 
@@ -42,7 +42,7 @@ describeWithEnvironment('EntryName', () => {
     const entry = parsedTrace.Renderer.allTraceEntries.find(e => e.name === Trace.Types.Events.Name.RUN_TASK);
     assert.isOk(entry);
 
-    const name = Components.EntryName.nameForEntry(entry, parsedTrace);
+    const name = Utils.EntryName.nameForEntry(entry, parsedTrace);
     assert.strictEqual(name, 'Task');
   });
 
@@ -59,7 +59,7 @@ describeWithEnvironment('EntryName', () => {
       }
     }
     assert.isOk(createEvent);
-    const name = Components.EntryName.nameForEntry(createEvent, parsedTrace);
+    const name = Utils.EntryName.nameForEntry(createEvent, parsedTrace);
     assert.strictEqual(name, 'WebSocket opened: wss://echo.websocket.org/');
   });
 
@@ -68,7 +68,7 @@ describeWithEnvironment('EntryName', () => {
       name: Trace.Types.Events.Name.WEB_SOCKET_DESTROY,
     } as unknown as Trace.Types.Events.WebSocketDestroy;
 
-    const name = Components.EntryName.nameForEntry(fakeDestroyEvent);
+    const name = Utils.EntryName.nameForEntry(fakeDestroyEvent);
     assert.strictEqual(name, 'WebSocket closed');
   });
 
@@ -76,7 +76,7 @@ describeWithEnvironment('EntryName', () => {
     const {parsedTrace} = await TraceLoader.traceEngine(this, 'slow-interaction-button-click.json.gz');
     const firstInteraction = parsedTrace.UserInteractions.interactionEvents.at(0);
     assert.isOk(firstInteraction);
-    const name = Components.EntryName.nameForEntry(firstInteraction);
+    const name = Utils.EntryName.nameForEntry(firstInteraction);
     assert.strictEqual(name, 'Pointer');
   });
 
@@ -84,7 +84,7 @@ describeWithEnvironment('EntryName', () => {
     const {parsedTrace} = await TraceLoader.traceEngine(this, 'slow-interaction-keydown.json.gz');
     const keydownInteraction = parsedTrace.UserInteractions.interactionEvents.find(e => e.type === 'keydown');
     assert.isOk(keydownInteraction);
-    const name = Components.EntryName.nameForEntry(keydownInteraction);
+    const name = Utils.EntryName.nameForEntry(keydownInteraction);
     assert.strictEqual(name, 'Keyboard');
   });
 
@@ -95,7 +95,7 @@ describeWithEnvironment('EntryName', () => {
     const firstInteraction = {...parsedTrace.UserInteractions.interactionEvents[0]};
     firstInteraction.type = 'unknown';
 
-    const name = Components.EntryName.nameForEntry(firstInteraction);
+    const name = Utils.EntryName.nameForEntry(firstInteraction);
     assert.strictEqual(name, 'Other');
   });
 
@@ -108,7 +108,7 @@ describeWithEnvironment('EntryName', () => {
       // reset this to avoid impacting other tests.
       const originalProfileNodeName = profileNode.functionName;
       profileNode.setFunctionName('testing-profile-name');
-      const name = Components.EntryName.nameForEntry(entry, parsedTrace);
+      const name = Utils.EntryName.nameForEntry(entry, parsedTrace);
       assert.strictEqual(name, 'testing-profile-name');
       profileNode.setFunctionName(originalProfileNodeName);
     });
@@ -121,7 +121,7 @@ describeWithEnvironment('EntryName', () => {
       // reset this to avoid impacting other tests.
       const originalProfileNodeName = profileNode.functionName;
       profileNode.setFunctionName('');
-      const name = Components.EntryName.nameForEntry(entry, parsedTrace);
+      const name = Utils.EntryName.nameForEntry(entry, parsedTrace);
       assert.strictEqual(name, 'performConcurrentWorkOnRoot');
       profileNode.setFunctionName(originalProfileNodeName);
     });

package/front_end/panels/timeline/{components → utils}/EntryName.ts

@@ -38,7 +38,7 @@ const UIStrings = {
   wsConnectionClosed: 'WebSocket closed',
 };
 
-const str_ = i18n.i18n.registerUIStrings('panels/timeline/components/EntryName.ts', UIStrings);
+const str_ = i18n.i18n.registerUIStrings('panels/timeline/utils/EntryName.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 /**

package/front_end/panels/timeline/{components → utils}/EntryStyles.ts

@@ -497,6 +497,24 @@ const UIStrings = {
    *@description Text in UIDevtools Utils of the Performance panel
    */
   drawing: 'Drawing',
+  /**
+   * @description Label for an event in the Performance panel indicating that a
+   * callback function has been scheduled to run at a later time using the
+   * postTask API.
+   */
+  schedulePostTaskCallback: 'Schedule postTask',
+  /**
+   * @description Label for an event in the Performance panel indicating that a
+   * callback function that was scheduled to run using the postTask API was
+   * fired (invoked).
+   */
+  runPostTaskCallback: 'Fire postTask',
+  /**
+   * @description Label for an event in the Performance panel indicating that a
+   * callback function that was scheduled to run at a later time using the
+   * postTask API was cancelled, so will no longer run.
+   */
+  abortPostTaskCallback: 'Cancel postTask',
 };
 
 export enum EventCategory {
@@ -517,7 +535,7 @@ export enum EventCategory {
 
 let mainEventCategories: EventCategory[];
 
-const str_ = i18n.i18n.registerUIStrings('panels/timeline/components/EntryStyles.ts', UIStrings);
+const str_ = i18n.i18n.registerUIStrings('panels/timeline/utils/EntryStyles.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class TimelineRecordStyle {
@@ -1033,6 +1051,15 @@ export function maybeInitSylesMap(): EventStylesMap {
 
     [Trace.Types.Events.Name.SCHEDULE_POST_MESSAGE]:
         new TimelineRecordStyle(i18nString(UIStrings.schedulePostMessage), defaultCategoryStyles.messaging),
+
+    [Trace.Types.Events.Name.SCHEDULE_POST_TASK_CALLBACK]:
+        new TimelineRecordStyle(i18nString(UIStrings.schedulePostTaskCallback), defaultCategoryStyles.scripting),
+
+    [Trace.Types.Events.Name.RUN_POST_TASK_CALLBACK]:
+        new TimelineRecordStyle(i18nString(UIStrings.runPostTaskCallback), defaultCategoryStyles.scripting),
+
+    [Trace.Types.Events.Name.ABORT_POST_TASK_CALLBACK]:
+        new TimelineRecordStyle(i18nString(UIStrings.abortPostTaskCallback), defaultCategoryStyles.scripting),
   };
   return eventStylesMap;
 }

package/front_end/panels/timeline/utils/Helpers.test.ts

@@ -2,11 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
-
 import * as Helpers from './Helpers.js';
 
-describeWithEnvironment('Helpers', () => {
+describe('Helpers', () => {
   it('createUrlLabels', function() {
     function fn(urls: string[], expected: string[]) {
       assert.deepEqual(Helpers.createUrlLabels(urls.map(url => new URL(url))), expected);
@@ -35,4 +33,11 @@ describeWithEnvironment('Helpers', () => {
        ['http://www.example.com/?k=1234567…', 'https://www.example.com/?k=1234567…']);
     fn(['https://www.example.com', 'https://www.example2.com'], ['/', 'www.example2.com']);
   });
+
+  it('shortenUrl', function() {
+    const url = new URL('https://cdn.permutive.com/models/v2/d2fb08da-1c03-4c8a-978f-ad8a96b4c31f-models.bin');
+    // Shows lastPath and then reveals more of it, per maxCharacters
+    assert.strictEqual(Helpers.shortenUrl(url, 40), 'd2fb08da-1c03-4c8a-9…96b4c31f-models.bin');
+    assert.strictEqual(Helpers.shortenUrl(url, 70), '/models/v2/d2fb08da-1c03-4c8a-978f-ad8a96b4c31f-models.bin');
+  });
 });

package/front_end/panels/timeline/utils/Helpers.ts

@@ -69,13 +69,12 @@ export function createUrlLabels(urls: URL[]): string[] {
  * Shortens the provided URL for use within a narrow display usecase.
  *
  * The resulting string will at least contain the last path component of the URL.
- * More components are included until a limit of 20 characters is reached.
+ * More components are included until a limit of maxChars (default 20) is reached.
  * No querystring is included.
  *
- * If the last path component is larger than 20 characters, the middle is elided.
+ * If the last path component is larger than maxChars characters, the middle is elided.
  */
-export function shortenUrl(url: URL): string {
-  const maxChars = 20;
+export function shortenUrl(url: URL, maxChars = 20): string {
   const parts = url.pathname.split('/');
   let shortenedUrl = parts.at(-1) ?? '';
 

package/front_end/panels/timeline/utils/IgnoreList.test.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 Common from '../../../core/common/common.js';
 import type * as Platform from '../../../core/platform/platform.js';
 import * as Bindings from '../../../models/bindings/bindings.js';
 import * as Trace from '../../../models/trace/trace.js';
@@ -51,4 +52,89 @@ describeWithMockConnection('isIgnoreListedEntry', () => {
     await resolver.install();
     assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
   });
+
+  it('ignores entries with a url in the source map\'s ignoreList field when the user enables known third party ignoring',
+     async () => {
+       const {ignoreListedURL, scriptId} = await loadCodeLocationResolvingScenario();
+
+       // This matches the location mapping added to the sourcemap.
+       const LINE_NUMBER = 3;
+       const COLUMN_NUMBER = 0;
+
+       const profileCallWithMappings =
+           makeProfileCall('function', 10, 100, Trace.Types.Events.ProcessID(1), Trace.Types.Events.ThreadID(1));
+       profileCallWithMappings.callFrame = {
+         lineNumber: LINE_NUMBER,
+         columnNumber: COLUMN_NUMBER,
+         functionName: 'ignore',
+         scriptId,
+         url: ignoreListedURL,
+       };
+
+       const workersData: Trace.Handlers.ModelHandlers.Workers.WorkersData = {
+         workerSessionIdEvents: [],
+         workerIdByThread: new Map(),
+         workerURLById: new Map(),
+       };
+       const traceWithMappings = {
+         Samples: makeMockSamplesHandlerData([profileCallWithMappings]),
+         Workers: workersData,
+       } as Trace.Handlers.Types.ParsedTrace;
+       const resolver = new Utils.SourceMapsResolver.SourceMapsResolver(traceWithMappings);
+       await resolver.install();
+       assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
+       const ignoreKnownThirdPartySetting =
+           Common.Settings.Settings.instance().moduleSetting('automatically-ignore-list-known-third-party-scripts');
+       const ignoreKnownThirdPartySettingValue = ignoreKnownThirdPartySetting.get();
+
+       ignoreKnownThirdPartySetting.set(true);
+       assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
+
+       ignoreKnownThirdPartySetting.set(false);
+       assert.isFalse(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
+
+       // restore to the original value.
+       ignoreKnownThirdPartySetting.set(ignoreKnownThirdPartySettingValue);
+     });
+  it('ignores entries belonging to content script when the user enables content script ignoring', async () => {
+    const {contentScriptURL, contentScriptId: scriptId} = await loadCodeLocationResolvingScenario();
+
+    const LINE_NUMBER = 0;
+    const COLUMN_NUMBER = 0;
+
+    const profileCallWithContentScript =
+        makeProfileCall('function', 10, 100, Trace.Types.Events.ProcessID(1), Trace.Types.Events.ThreadID(1));
+    profileCallWithContentScript.callFrame = {
+      lineNumber: LINE_NUMBER,
+      columnNumber: COLUMN_NUMBER,
+      functionName: '',
+      scriptId,
+      url: contentScriptURL,
+    };
+
+    const workersData: Trace.Handlers.ModelHandlers.Workers.WorkersData = {
+      workerSessionIdEvents: [],
+      workerIdByThread: new Map(),
+      workerURLById: new Map(),
+    };
+    const traceWithMappings = {
+      Samples: makeMockSamplesHandlerData([profileCallWithContentScript]),
+      Workers: workersData,
+    } as Trace.Handlers.Types.ParsedTrace;
+    const resolver = new Utils.SourceMapsResolver.SourceMapsResolver(traceWithMappings);
+    await resolver.install();
+    assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
+
+    const ignoreContentScriptSetting = Common.Settings.Settings.instance().moduleSetting('skip-content-scripts');
+    const ignoreContentScriptSettingValue = ignoreContentScriptSetting.get();
+
+    ignoreContentScriptSetting.set(true);
+    assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
+
+    ignoreContentScriptSetting.set(false);
+    assert.isFalse(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
+
+    // restore to the original value.
+    ignoreContentScriptSetting.set(ignoreContentScriptSettingValue);
+  });
 });

package/front_end/panels/timeline/utils/IgnoreList.ts

@@ -15,10 +15,17 @@ export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
   const rawUrl = entry.callFrame.url as Platform.DevToolsPath.UrlString;
 
   const sourceMappedData = SourceMapsResolver.resolvedCodeLocationForEntry(entry);
-  const resolvedUrl = sourceMappedData?.devtoolsLocation?.uiSourceCode.url();
-  return resolvedUrl ? isIgnoreListedURL(resolvedUrl) : isIgnoreListedURL(rawUrl);
+  const script = sourceMappedData?.script;
+  const uiSourceCode = sourceMappedData?.devtoolsLocation?.uiSourceCode;
+  const resolvedUrl = uiSourceCode?.url();
+  const isKnownThirdParty = uiSourceCode?.isKnownThirdParty();
+  const isContentScript = script?.isContentScript();
+  const ignoreListOptions: Bindings.IgnoreListManager.IgnoreListGeneralRules = {isContentScript, isKnownThirdParty};
+  const urlToUse = resolvedUrl || rawUrl;
+  return isIgnoreListedURL(urlToUse, ignoreListOptions);
 }
 
-export function isIgnoreListedURL(url: Platform.DevToolsPath.UrlString): boolean {
-  return Bindings.IgnoreListManager.IgnoreListManager.instance().isUserIgnoreListedURL(url);
+export function isIgnoreListedURL(
+    url: Platform.DevToolsPath.UrlString, options?: Bindings.IgnoreListManager.IgnoreListGeneralRules): boolean {
+  return Bindings.IgnoreListManager.IgnoreListManager.instance().isUserIgnoreListedURL(url, options);
 }

package/front_end/panels/timeline/utils/NetworkRequest.ts

@@ -22,7 +22,7 @@ export function createTimelineNetworkRequest(syntheticNetworkRequest: Trace.Type
 }
 
 // Add a wrapper class here.
-// The reason is the `Reveal in Network panel` option is handled by the context menu provider, which will add this
+// The reason is the `Open in Network panel` option is handled by the context menu provider, which will add this
 // option for all supporting types. And there are a lot of context menu providers that support
 // `SDK.NetworkRequest.NetworkRequest`, for example `Override content` by PersistenceActions, but we so far just want
 // the one to reveal in network panel, so add a new class which will only be supported by Network panel. Also we want to

package/front_end/panels/timeline/utils/SourceMapsResolver.test.ts

@@ -28,8 +28,14 @@ import * as Utils from './utils.js';
 const MINIFIED_FUNCTION_NAME = 'minified';
 const AUTHORED_FUNCTION_NAME = 'someFunction';
 
-export async function loadCodeLocationResolvingScenario():
-    Promise<{authoredScriptURL: string, genScriptURL: string, scriptId: Protocol.Runtime.ScriptId}> {
+export async function loadCodeLocationResolvingScenario(): Promise<{
+  authoredScriptURL: string,
+  genScriptURL: string,
+  scriptId: Protocol.Runtime.ScriptId,
+  ignoreListedURL: string,
+  contentScriptURL: string,
+  contentScriptId: Protocol.Runtime.ScriptId,
+}> {
   const target = createTarget();
 
   const targetManager = SDK.TargetManager.TargetManager.instance();
@@ -43,32 +49,59 @@ export async function loadCodeLocationResolvingScenario():
   });
 
   const backend = new MockProtocolBackend();
+
+  // The following mock data creates a source mapping from two authored
+  // scripts to a single complied script. One of the sources
+  // (ignored.ts) is marked as ignore listed in the source map.
   const sourceRoot = 'http://example.com';
   const scriptInfo = {
     url: `${sourceRoot}/test.out.js`,
-    content: 'function f(x) {\n  console.log(x);\n}\n',
+    content: 'function f(x) {\n  console.log(x);\n}\nfunction ignore(y){\n console.log(y);\n}',
   };
-  const authoredScripName = 'test.ts';
-  const authoredScriptURL = `${sourceRoot}/${authoredScripName}`;
-
+  const authoredScriptName = 'test.ts';
+  const ignoredScriptName = 'ignored.ts';
+  const authoredScriptURL = `${sourceRoot}/${authoredScriptName}`;
+  const ignoreListedScriptURL = `${sourceRoot}/${ignoredScriptName}`;
+  const sourceMap = encodeSourceMap(
+      [
+        `0:9 => ${authoredScriptName}:0:1`,
+        `1:0 => ${authoredScriptName}:4:0`,
+        `1:2 => ${authoredScriptName}:4:2`,
+        `2:0 => ${authoredScriptName}:2:0`,
+        `3:0 => ${ignoredScriptName}:3:0`,
+      ],
+      sourceRoot);
+  sourceMap.sources = [authoredScriptURL, ignoreListedScriptURL];
+  sourceMap.ignoreList = [1];
   const sourceMapInfo = {
     url: `${scriptInfo.url}.map`,
-    content: encodeSourceMap(
-        [
-          `0:9 => ${authoredScripName}:0:1`,
-          `1:0 => ${authoredScripName}:4:0`,
-          `1:2 => ${authoredScripName}:4:2`,
-          `2:0 => ${authoredScripName}:2:0`,
-        ],
-        sourceRoot),
+    content: sourceMap,
+  };
+
+  // The following mock data creates content script
+  const contentScriptInfo = {
+    url: `${sourceRoot}/content-script.js`,
+    content: 'console.log("content script loaded");',
+    isContentScript: true,
   };
-  const [, script] = await Promise.all([
-    debuggerWorkspaceBinding.waitForUISourceCodeAdded(
-        `${sourceRoot}/test.ts` as Platform.DevToolsPath.UrlString, target),
+
+  // Load mock data in devtools
+  const [, , script, , contentScript] = await Promise.all([
+    debuggerWorkspaceBinding.waitForUISourceCodeAdded(authoredScriptURL as Platform.DevToolsPath.UrlString, target),
+    debuggerWorkspaceBinding.waitForUISourceCodeAdded(ignoreListedScriptURL as Platform.DevToolsPath.UrlString, target),
     backend.addScript(target, scriptInfo, sourceMapInfo),
+    debuggerWorkspaceBinding.waitForUISourceCodeAdded(contentScriptInfo.url as Platform.DevToolsPath.UrlString, target),
+    backend.addScript(target, contentScriptInfo, null),
   ]);
 
-  return {authoredScriptURL, scriptId: script.scriptId, genScriptURL: scriptInfo.url};
+  return {
+    authoredScriptURL,
+    scriptId: script.scriptId,
+    genScriptURL: scriptInfo.url,
+    ignoreListedURL: ignoreListedScriptURL,
+    contentScriptURL: contentScriptInfo.url,
+    contentScriptId: contentScript.scriptId,
+  };
 }
 
 function parsedTraceFromProfileCalls(profileCalls: Trace.Types.Events.SyntheticProfileCall[]):

package/front_end/panels/timeline/utils/SourceMapsResolver.ts

@@ -13,6 +13,7 @@ import * as Workspace from '../../../models/workspace/workspace.js';
 type ResolvedCodeLocationData = {
   name: string|null,
   devtoolsLocation: Workspace.UISourceCode.UILocation|null,
+  script: SDK.Script.Script|null,
 };
 export class SourceMappingsUpdated extends Event {
   static readonly eventName = 'sourcemappingsupdated';
@@ -178,6 +179,7 @@ export class SourceMapsResolver extends EventTarget {
           node.setFunctionName(resolvedFunctionName);
 
           const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
+          const script = debuggerModel?.scriptForId(node.scriptId) || null;
           const location = debuggerModel &&
               new SDK.DebuggerModel.Location(
                   debuggerModel, node.callFrame.scriptId, node.callFrame.lineNumber, node.callFrame.columnNumber);
@@ -187,7 +189,7 @@ export class SourceMapsResolver extends EventTarget {
           updatedMappings ||= Boolean(uiLocation);
 
           SourceMapsResolver.storeResolvedNodeDataForEntry(
-              pid, tid, node.callFrame, {name: resolvedFunctionName, devtoolsLocation: uiLocation});
+              pid, tid, node.callFrame, {name: resolvedFunctionName, devtoolsLocation: uiLocation, script});
         }
       }
     }

package/front_end/panels/timeline/utils/utils.ts

@@ -1,6 +1,9 @@
 // Copyright 2024 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+import * as AICallTree from './AICallTree.js';
+import * as EntryName from './EntryName.js';
+import * as EntryStyles from './EntryStyles.js';
 import * as Helpers from './Helpers.js';
 import * as IgnoreList from './IgnoreList.js';
 import * as ImageCache from './ImageCache.js';
@@ -8,6 +11,9 @@ import * as NetworkRequest from './NetworkRequest.js';
 import * as SourceMapsResolver from './SourceMapsResolver.js';
 
 export {
+  AICallTree,
+  EntryName,
+  EntryStyles,
   Helpers,
   IgnoreList,
   ImageCache,