chrome-devtools-frontend 1.0.1652307 → 1.0.1656291

package/front_end/models/persistence/IsolatedFileSystemManager.ts

@@ -6,6 +6,7 @@ import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 
 import type {FilesChangedData} from './FileSystemWorkspaceBinding.js';
 import {IsolatedFileSystem} from './IsolatedFileSystem.js';
@@ -24,7 +25,6 @@ const UIStrings = {
 } as const;
 const str_ = i18n.i18n.registerUIStrings('models/persistence/IsolatedFileSystemManager.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-let isolatedFileSystemManagerInstance: IsolatedFileSystemManager|null;
 
 export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #fileSystems: Map<Platform.DevToolsPath.UrlString, PlatformFileSystem>;
@@ -33,8 +33,12 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
   readonly #workspaceFolderExcludePatternSetting: Common.Settings.RegExpSetting;
   private fileSystemRequestResolve: ((arg0: IsolatedFileSystem|null) => void)|null;
   private readonly fileSystemsLoadedPromise: Promise<IsolatedFileSystem[]>;
-  private constructor() {
+  readonly #settings: Common.Settings.Settings;
+  readonly #console: Common.Console.Console;
+  constructor(settings: Common.Settings.Settings, console: Common.Console.Console) {
     super();
+    this.#settings = settings;
+    this.#console = console;
 
     this.#fileSystems = new Map();
     this.callbacks = new Map();
@@ -90,24 +94,31 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
       defaultExcludedFolders = defaultExcludedFolders.concat(defaultLinuxExcludedFolders);
     }
     const defaultExcludedFoldersPattern = defaultExcludedFolders.join('|');
-    this.#workspaceFolderExcludePatternSetting = Common.Settings.Settings.instance().createRegExpSetting(
+    this.#workspaceFolderExcludePatternSetting = this.#settings.createRegExpSetting(
         'workspace-folder-exclude-pattern', defaultExcludedFoldersPattern, Host.Platform.isWin() ? 'i' : '');
 
     this.fileSystemRequestResolve = null;
     this.fileSystemsLoadedPromise = this.requestFileSystems();
   }
 
-  static instance(opts: {forceNew: boolean|null} = {forceNew: null}): IsolatedFileSystemManager {
-    const {forceNew} = opts;
-    if (!isolatedFileSystemManagerInstance || forceNew) {
-      isolatedFileSystemManagerInstance = new IsolatedFileSystemManager();
+  static instance(opts: {
+    forceNew?: boolean|null,
+    settings?: Common.Settings.Settings|null,
+    console?: Common.Console.Console|null,
+  } = {}): IsolatedFileSystemManager {
+    const forceNew = opts.forceNew ?? null;
+    const settings = opts.settings ?? Common.Settings.Settings.instance();
+    const console = opts.console ?? Common.Console.Console.instance();
+    if (!Root.DevToolsContext.globalInstance().has(IsolatedFileSystemManager) || forceNew) {
+      const instance = new IsolatedFileSystemManager(settings, console);
+      Root.DevToolsContext.globalInstance().set(IsolatedFileSystemManager, instance);
     }
 
-    return isolatedFileSystemManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(IsolatedFileSystemManager);
   }
 
   static removeInstance(): void {
-    isolatedFileSystemManagerInstance = null;
+    Root.DevToolsContext.globalInstance().delete(IsolatedFileSystemManager);
   }
 
   private requestFileSystems(): Promise<IsolatedFileSystem[]> {
@@ -160,7 +171,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     const fileSystemURL = Common.ParsedURL.ParsedURL.rawPathToUrlString(fileSystem.fileSystemPath);
     const promise = IsolatedFileSystem.create(
         this, fileSystemURL, embedderPath, hostFileSystemTypeToPlatformFileSystemType(fileSystem.type),
-        fileSystem.fileSystemName, fileSystem.rootURL, fileSystem.type === 'automatic');
+        fileSystem.fileSystemName, fileSystem.rootURL, fileSystem.type === 'automatic', this.#settings);
     return promise.then(storeFileSystem.bind(this));
 
     function storeFileSystem(this: IsolatedFileSystemManager, fileSystem: IsolatedFileSystem|null): IsolatedFileSystem|
@@ -188,7 +199,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     const {errorMessage, fileSystem} = event.data;
     if (errorMessage) {
       if (errorMessage !== '<selection cancelled>' && errorMessage !== '<permission denied>') {
-        Common.Console.Console.instance().error(i18nString(UIStrings.unableToAddFilesystemS, {PH1: errorMessage}));
+        this.#console.error(i18nString(UIStrings.unableToAddFilesystemS, {PH1: errorMessage}));
       }
       if (!this.fileSystemRequestResolve) {
         return;

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as Breakpoints from '../breakpoints/breakpoints.js';
@@ -15,8 +16,6 @@ import {type FileSystem, FileSystemWorkspaceBinding} from './FileSystemWorkspace
 import {IsolatedFileSystemManager} from './IsolatedFileSystemManager.js';
 import {PersistenceBinding, PersistenceImpl} from './PersistenceImpl.js';
 
-let networkPersistenceManagerInstance: NetworkPersistenceManager|null;
-
 const forbiddenUrls = ['chromewebstore.google.com', 'chrome.google.com'];
 
 export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
@@ -24,8 +23,14 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   #bindings = new WeakMap<Workspace.UISourceCode.UISourceCode, PersistenceBinding>();
   readonly #originalResponseContentPromises = new WeakMap<Workspace.UISourceCode.UISourceCode, Promise<string|null>>();
   #savingForOverrides = new WeakSet<Workspace.UISourceCode.UISourceCode>();
-  #enabledSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('persistence-network-overrides-enabled');
+  readonly #enabledSetting: Common.Settings.Setting<boolean>;
   readonly #workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly #persistence: PersistenceImpl;
+  readonly #breakpointManager: Breakpoints.BreakpointManager.BreakpointManager;
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #settings: Common.Settings.Settings;
+  readonly #isolatedFileSystemManager: IsolatedFileSystemManager;
+  readonly #multitargetNetworkManager: SDK.NetworkManager.MultitargetNetworkManager;
   readonly #networkUISourceCodeForEncodedPath =
       new Map<Platform.DevToolsPath.EncodedPathString, Workspace.UISourceCode.UISourceCode>();
   readonly #interceptionHandlerBound: (interceptedRequest: SDK.NetworkManager.InterceptedRequest) => Promise<void>;
@@ -39,12 +44,27 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   readonly #eventDispatchThrottler = new Common.Throttler.Throttler(50);
   #headerOverridesForEventDispatch = new Set<Workspace.UISourceCode.UISourceCode>();
 
-  private constructor(workspace: Workspace.Workspace.WorkspaceImpl) {
+  constructor(
+      workspace: Workspace.Workspace.WorkspaceImpl,
+      persistence: PersistenceImpl,
+      breakpointManager: Breakpoints.BreakpointManager.BreakpointManager,
+      targetManager: SDK.TargetManager.TargetManager,
+      settings: Common.Settings.Settings,
+      isolatedFileSystemManager: IsolatedFileSystemManager,
+      multitargetNetworkManager: SDK.NetworkManager.MultitargetNetworkManager,
+  ) {
     super();
 
-    this.#enabledSetting.addChangeListener(this.enabledChanged, this);
-
     this.#workspace = workspace;
+    this.#persistence = persistence;
+    this.#breakpointManager = breakpointManager;
+    this.#targetManager = targetManager;
+    this.#settings = settings;
+    this.#isolatedFileSystemManager = isolatedFileSystemManager;
+    this.#multitargetNetworkManager = multitargetNetworkManager;
+
+    this.#enabledSetting = this.#settings.moduleSetting<boolean>('persistence-network-overrides-enabled');
+    this.#enabledSetting.addChangeListener(this.enabledChanged, this);
 
     this.#interceptionHandlerBound = this.interceptionHandler.bind(this);
 
@@ -55,13 +75,12 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
       void this.onProjectRemoved(event.data);
     });
 
-    PersistenceImpl.instance().addNetworkInterceptor(this.canHandleNetworkUISourceCode.bind(this));
-    Breakpoints.BreakpointManager.BreakpointManager.instance().addUpdateBindingsCallback(
-        this.networkUISourceCodeAdded.bind(this));
+    this.#persistence.addNetworkInterceptor(this.canHandleNetworkUISourceCode.bind(this));
+    this.#breakpointManager.addUpdateBindingsCallback(this.networkUISourceCodeAdded.bind(this));
 
     void this.enabledChanged();
 
-    SDK.TargetManager.TargetManager.instance().observeTargets(this);
+    this.#targetManager.observeTargets(this);
   }
 
   targetAdded(): void {
@@ -76,14 +95,29 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     workspace: Workspace.Workspace.WorkspaceImpl|null,
   } = {forceNew: null, workspace: null}): NetworkPersistenceManager {
     const {forceNew, workspace} = opts;
-    if (!networkPersistenceManagerInstance || forceNew) {
+    if (!Root.DevToolsContext.globalInstance().has(NetworkPersistenceManager) || forceNew) {
       if (!workspace) {
         throw new Error('Missing workspace for NetworkPersistenceManager');
       }
-      networkPersistenceManagerInstance = new NetworkPersistenceManager(workspace);
+      Root.DevToolsContext.globalInstance().set(
+          NetworkPersistenceManager,
+          new NetworkPersistenceManager(
+              workspace,
+              PersistenceImpl.instance(),
+              Breakpoints.BreakpointManager.BreakpointManager.instance(),
+              SDK.TargetManager.TargetManager.instance(),
+              Common.Settings.Settings.instance(),
+              IsolatedFileSystemManager.instance(),
+              SDK.NetworkManager.MultitargetNetworkManager.instance(),
+              ),
+      );
     }
 
-    return networkPersistenceManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(NetworkPersistenceManager);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(NetworkPersistenceManager);
   }
 
   active(): boolean {
@@ -111,24 +145,20 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     if (this.#enabled) {
       Host.userMetrics.actionTaken(Host.UserMetrics.Action.PersistenceNetworkOverridesEnabled);
       this.#eventDescriptors = [
-        Workspace.Workspace.WorkspaceImpl.instance().addEventListener(
-            Workspace.Workspace.Events.UISourceCodeRenamed,
-            event => {
-              void this.uiSourceCodeRenamedListener(event);
-            }),
-        Workspace.Workspace.WorkspaceImpl.instance().addEventListener(
-            Workspace.Workspace.Events.UISourceCodeAdded,
-            event => {
-              void this.uiSourceCodeAdded(event);
-            }),
-        Workspace.Workspace.WorkspaceImpl.instance().addEventListener(
-            Workspace.Workspace.Events.UISourceCodeRemoved,
-            event => {
-              void this.uiSourceCodeRemovedListener(event);
-            }),
-        Workspace.Workspace.WorkspaceImpl.instance().addEventListener(
-            Workspace.Workspace.Events.WorkingCopyCommitted,
-            event => this.onUISourceCodeWorkingCopyCommitted(event.data.uiSourceCode)),
+        this.#workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeRenamed,
+                                         event => {
+                                           void this.uiSourceCodeRenamedListener(event);
+                                         }),
+        this.#workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded,
+                                         event => {
+                                           void this.uiSourceCodeAdded(event);
+                                         }),
+        this.#workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeRemoved,
+                                         event => {
+                                           void this.uiSourceCodeRemovedListener(event);
+                                         }),
+        this.#workspace.addEventListener(Workspace.Workspace.Events.WorkingCopyCommitted,
+                                         event => this.onUISourceCodeWorkingCopyCommitted(event.data.uiSourceCode)),
       ];
       await this.updateActiveProject();
     } else {
@@ -158,8 +188,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
 
   private async updateActiveProject(): Promise<void> {
     const wasActive = this.#active;
-    this.#active =
-        Boolean(this.#enabledSetting.get() && SDK.TargetManager.TargetManager.instance().rootTarget() && this.#project);
+    this.#active = Boolean(this.#enabledSetting.get() && this.#targetManager.rootTarget() && this.#project);
     if (this.#active === wasActive) {
       return;
     }
@@ -178,7 +207,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
           [...this.#project.uiSourceCodes()].map(uiSourceCode => this.filesystemUISourceCodeRemoved(uiSourceCode)));
       this.#networkUISourceCodeForEncodedPath.clear();
     }
-    PersistenceImpl.instance().refreshAutomapping();
+    this.#persistence.refreshAutomapping();
   }
 
   encodedPathFromUrl(url: Platform.DevToolsPath.UrlString, ignoreInactive?: boolean):
@@ -270,7 +299,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     const folderUrlFromRequest =
         Common.ParsedURL.ParsedURL.substring(fileUrlFromRequest, 0, fileUrlFromRequest.lastIndexOf('/'));
     const headersFileUrl = Common.ParsedURL.ParsedURL.concatenate(folderUrlFromRequest, '/', HEADERS_FILENAME);
-    return Workspace.Workspace.WorkspaceImpl.instance().uiSourceCodeForURL(headersFileUrl);
+    return this.#workspace.uiSourceCodeForURL(headersFileUrl);
   }
 
   async getOrCreateHeadersUISourceCodeFromUrl(url: Platform.DevToolsPath.UrlString):
@@ -315,7 +344,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   #innerUnbind(binding: PersistenceBinding): Promise<void> {
     this.#bindings.delete(binding.network);
     this.#bindings.delete(binding.fileSystem);
-    return PersistenceImpl.instance().removeBinding(binding);
+    return this.#persistence.removeBinding(binding);
   }
 
   async #bind(
@@ -352,12 +381,12 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     const binding = new PersistenceBinding(networkUISourceCode, fileSystemUISourceCode);
     this.#bindings.set(networkUISourceCode, binding);
     this.#bindings.set(fileSystemUISourceCode, binding);
-    await PersistenceImpl.instance().addBinding(binding);
+    await this.#persistence.addBinding(binding);
     const uiSourceCodeOfTruth =
         this.#savingForOverrides.has(networkUISourceCode) ? networkUISourceCode : fileSystemUISourceCode;
     const contentDataOrError = await uiSourceCodeOfTruth.requestContentData();
     const {content, isEncoded} = TextUtils.ContentData.ContentData.asDeferredContent(contentDataOrError);
-    PersistenceImpl.instance().syncContent(uiSourceCodeOfTruth, content || '', isEncoded);
+    this.#persistence.syncContent(uiSourceCodeOfTruth, content || '', isEncoded);
   }
 
   private onUISourceCodeWorkingCopyCommitted(uiSourceCode: Workspace.UISourceCode.UISourceCode): void {
@@ -398,7 +427,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     if (this.#shouldPromptSaveForOverridesDialog(uiSourceCode)) {
       Host.userMetrics.actionTaken(Host.UserMetrics.Action.OverrideContentContextMenuSetup);
       await new Promise<void>(resolve => this.dispatchEventToListeners(Events.LOCAL_OVERRIDES_REQUESTED, resolve));
-      await IsolatedFileSystemManager.instance().addFileSystem('overrides');
+      await this.#isolatedFileSystemManager.addFileSystem('overrides');
     }
 
     if (!this.project()) {
@@ -683,8 +712,8 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   async #innerUpdateInterceptionPatterns(): Promise<void> {
     this.#headerOverridesMap.clear();
     if (!this.#active || !this.#project) {
-      return await SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
-          [], this.#interceptionHandlerBound);
+      return await this.#multitargetNetworkManager.setInterceptionHandlerForPatterns([],
+                                                                                     this.#interceptionHandlerBound);
     }
     let patterns = new Set<string>();
     for (const uiSourceCode of this.#project.uiSourceCodes()) {
@@ -713,9 +742,9 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
       }
     }
 
-    return await SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
-        Array.from(patterns).map(
-            pattern => ({urlPattern: pattern, requestStage: Protocol.Fetch.RequestStage.Response})),
+    return await this.#multitargetNetworkManager.setInterceptionHandlerForPatterns(
+        Array.from(patterns).map(pattern =>
+                                     ({urlPattern: pattern, requestStage: Protocol.Fetch.RequestStage.Response})),
         this.#interceptionHandlerBound);
   }
 

package/front_end/models/persistence/PersistenceImpl.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Bindings from '../bindings/bindings.js';
 import * as BreakpointManager from '../breakpoints/breakpoints.js';
@@ -13,8 +14,6 @@ import * as Workspace from '../workspace/workspace.js';
 
 import {Automapping, type AutomappingStatus} from './Automapping.js';
 
-let persistenceInstance: PersistenceImpl;
-
 export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #workspace: Workspace.Workspace.WorkspaceImpl;
   readonly #breakpointManager: BreakpointManager.BreakpointManager.BreakpointManager;
@@ -40,14 +39,14 @@ export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     breakpointManager: BreakpointManager.BreakpointManager.BreakpointManager|null,
   } = {forceNew: null, workspace: null, breakpointManager: null}): PersistenceImpl {
     const {forceNew, workspace, breakpointManager} = opts;
-    if (!persistenceInstance || forceNew) {
+    if (!Root.DevToolsContext.globalInstance().has(PersistenceImpl) || forceNew) {
       if (!workspace || !breakpointManager) {
         throw new Error('Missing arguments for workspace');
       }
-      persistenceInstance = new PersistenceImpl(workspace, breakpointManager);
+      Root.DevToolsContext.globalInstance().set(PersistenceImpl, new PersistenceImpl(workspace, breakpointManager));
     }
 
-    return persistenceInstance;
+    return Root.DevToolsContext.globalInstance().get(PersistenceImpl);
   }
 
   addNetworkInterceptor(interceptor: (arg0: Workspace.UISourceCode.UISourceCode) => boolean): void {

package/front_end/models/project_settings/ProjectSettingsModel.ts

@@ -4,7 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
-import type * as Root from '../../core/root/root.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 
 /** The security origin for all DevTools (front-end) resources. */
@@ -72,8 +72,6 @@ export type ProjectSettingsAvailability = 'available'|'unavailable';
 const EMPTY_PROJECT_SETTINGS: ProjectSettings = Object.freeze({});
 const IDLE_PROMISE: Promise<void> = Promise.resolve();
 
-let projectSettingsModelInstance: ProjectSettingsModel|undefined;
-
 export class ProjectSettingsModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #pageResourceLoader: SDK.PageResourceLoader.PageResourceLoader;
   readonly #targetManager: SDK.TargetManager.TargetManager;
@@ -108,7 +106,7 @@ export class ProjectSettingsModel extends Common.ObjectWrapper.ObjectWrapper<Eve
     return this.#promise.then(() => this.#projectSettings);
   }
 
-  private constructor(
+  constructor(
       hostConfig: Root.Runtime.HostConfig,
       pageResourceLoader: SDK.PageResourceLoader.PageResourceLoader,
       targetManager: SDK.TargetManager.TargetManager,
@@ -140,24 +138,27 @@ export class ProjectSettingsModel extends Common.ObjectWrapper.ObjectWrapper<Eve
     pageResourceLoader: SDK.PageResourceLoader.PageResourceLoader|null,
     targetManager: SDK.TargetManager.TargetManager|null,
   }): ProjectSettingsModel {
-    if (!projectSettingsModelInstance || forceNew) {
+    if (!Root.DevToolsContext.globalInstance().has(ProjectSettingsModel) || forceNew) {
       if (!hostConfig || !pageResourceLoader || !targetManager) {
         throw new Error(
             'Unable to create ProjectSettingsModel: ' +
             'hostConfig, pageResourceLoader, and targetManager must be provided');
       }
-      projectSettingsModelInstance = new ProjectSettingsModel(hostConfig, pageResourceLoader, targetManager);
+      Root.DevToolsContext.globalInstance().set(
+          ProjectSettingsModel,
+          new ProjectSettingsModel(hostConfig, pageResourceLoader, targetManager),
+      );
     }
-    return projectSettingsModelInstance;
+    return Root.DevToolsContext.globalInstance().get(ProjectSettingsModel);
   }
 
   /**
-   * Clears the `ProjectSettingsModel` singleton (if any).
+   * Clears the `ProjectSettingsModel` singleton (if any);
    */
   static removeInstance(): void {
-    if (projectSettingsModelInstance) {
-      projectSettingsModelInstance.#dispose();
-      projectSettingsModelInstance = undefined;
+    if (Root.DevToolsContext.globalInstance().has(ProjectSettingsModel)) {
+      Root.DevToolsContext.globalInstance().get(ProjectSettingsModel).#dispose();
+      Root.DevToolsContext.globalInstance().delete(ProjectSettingsModel);
     }
   }
 

package/front_end/models/trace/EntityMapper.ts

@@ -118,7 +118,7 @@ export class EntityMapper {
     const sourceLocationEvents: Types.Events.Event[] = [];
     // The events that don't match the source location, but that we should keep mapped to its current entity.
     const unrelatedEvents: Types.Events.Event[] = [];
-    currentEntityEvents?.forEach(e => {
+    currentEntityEvents?.forEach((e: Types.Events.Event) => {
       const cf = Helpers.Trace.getStackTraceTopCallFrameInEventPayload(e);
 
       const matchesCallFrame = cf && Helpers.Trace.isMatchingCallFrame(cf, callFrame);

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

@@ -7,21 +7,14 @@ import * as Types from '../types/types.js';
 
 import type {HandlerName} from './types.js';
 
-// Each thread contains events. Events indicate the thread and process IDs, which are
-// used to store the event in the correct process thread entry below.
-let unpairedAsyncEvents: Types.Events.PipelineReporter[] = [];
-
 let legacyScreenshotEvents: Types.Events.LegacyScreenshot[] = [];
 let modernScreenshotEvents: Types.Events.Screenshot[] = [];
 let syntheticScreenshots: Types.Events.LegacySyntheticScreenshot[] = [];
-let frameSequenceToTs: Record<string, Types.Timing.Micro> = {};
 
 export function reset(): void {
-  unpairedAsyncEvents = [];
   legacyScreenshotEvents = [];
   syntheticScreenshots = [];
   modernScreenshotEvents = [];
-  frameSequenceToTs = {};
 }
 
 export function handleEvent(event: Types.Events.Event): void {
@@ -29,39 +22,26 @@ export function handleEvent(event: Types.Events.Event): void {
     legacyScreenshotEvents.push(event);
   } else if (Types.Events.isScreenshot(event)) {
     modernScreenshotEvents.push(event);
-  } else if (Types.Events.isPipelineReporter(event)) {
-    unpairedAsyncEvents.push(event);
   }
 }
 
 export async function finalize(): Promise<void> {
-  const pipelineReporterEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(unpairedAsyncEvents);
-
-  frameSequenceToTs = Object.fromEntries(pipelineReporterEvents.map(evt => {
-    const args = evt.args.data.beginEvent.args;
-    const frameReporter = 'frame_reporter' in args ? args.frame_reporter : args.chrome_frame_reporter;
-    const frameSequenceId = frameReporter.frame_sequence;
-    const presentationTs = Types.Timing.Micro(evt.ts + evt.dur);
-    return [frameSequenceId, presentationTs];
-  }));
-
   for (const snapshotEvent of legacyScreenshotEvents) {
     const {cat, name, ph, pid, tid} = snapshotEvent;
-    const syntheticEvent = Helpers.SyntheticEvents.SyntheticEventsManager.registerSyntheticEvent<
-        Types.Events.LegacySyntheticScreenshot>({
-      rawSourceEvent: snapshotEvent,
-      cat,
-      name,
-      ph,
-      pid,
-      tid,
-      // TODO(paulirish, crbug.com/41363012): investigate why getPresentationTimestamp(snapshotEvent) seems less accurate. Resolve screenshot timing inaccuracy.
-      // `getPresentationTimestamp(snapshotEvent) - snapshotEvent.ts` is how many microsec the screenshot should be adjusted to the right/later
-      ts: snapshotEvent.ts,
-      args: {
-        dataUri: `data:image/jpg;base64,${snapshotEvent.args.snapshot}`,
-      },
-    });
+    const syntheticEvent =
+        Helpers.SyntheticEvents.SyntheticEventsManager.registerSyntheticEvent<Types.Events.LegacySyntheticScreenshot>({
+          rawSourceEvent: snapshotEvent,
+          cat,
+          name,
+          ph,
+          pid,
+          tid,
+          // TODO(paulirish, crbug.com/41363012): fix snapshot timestamps.
+          ts: snapshotEvent.ts,
+          args: {
+            dataUri: `data:image/jpg;base64,${snapshotEvent.args.snapshot}`,
+          },
+        });
     syntheticScreenshots.push(syntheticEvent);
   }
 }
@@ -73,31 +53,6 @@ export function screenshotImageDataUri(event: Types.Events.LegacySyntheticScreen
   return `data:image/jpg;base64,${event.args.snapshot}`;
 }
 
-/**
- * Correct the screenshot timestamps
- * The screenshot 'snapshot object' trace event has the "frame sequence number" attached as an ID.
- * We match that up with the "PipelineReporter" trace events as they terminate at presentation.
- * Presentation == when the pixels hit the screen. AKA Swap on the GPU
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function getPresentationTimestamp(screenshotEvent: Types.Events.LegacyScreenshot): Types.Timing.Micro {
-  const frameSequence = parseInt(screenshotEvent.id, 16);
-  // If it's 1, then it's an old trace (before https://crrev.com/c/4957973) and cannot be corrected.
-  if (frameSequence === 1) {
-    return screenshotEvent.ts;
-  }
-  // The screenshot trace event's `ts` reflects the "expected display time" which is ESTIMATE.
-  // It is set by the compositor frame sink from the `expected_display_time`, which is based on a previously known
-  // frame start PLUS the vsync interval (eg 16.6ms)
-  const updatedTs = frameSequenceToTs[frameSequence];
-  // Do we always find a match? No...
-  // We generally don't match the very first screenshot and, sometimes, the last
-  // The very first screenshot is requested immediately (even if nothing is painting). As a result there's no compositor
-  // instrumentation running alongside.
-  // The last one is sometimes missing as because the trace terminates right before the associated PipelineReporter is emitted.
-  return updatedTs ?? screenshotEvent.ts;
-}
-
 export interface Data {
   // These are nullable because in January 2025 a CL in Chromium
   // crrev.com/c/6197645 landed which changed the format of screenshots. For a