chrome-devtools-frontend 1.0.1651641 → 1.0.1654411

package/front_end/models/live-metrics/LiveMetrics.ts

@@ -291,7 +291,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
         const warnings: string[] = [];
         const lcpEvent: LcpValue = {
           value: webVitalsEvent.value,
-          phases: webVitalsEvent.phases,
+          subparts: webVitalsEvent.subparts,
           warnings,
         };
         if (webVitalsEvent.nodeIndex !== undefined) {
@@ -323,7 +323,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       case 'INP': {
         const inpEvent: InpValue = {
           value: webVitalsEvent.value,
-          phases: webVitalsEvent.phases,
+          subparts: webVitalsEvent.subparts,
           interactionId: `interaction-${webVitalsEvent.entryGroupId}-${webVitalsEvent.startTime}`,
         };
         this.#inpValue = inpEvent;
@@ -345,7 +345,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
             interactionType: webVitalsEvent.interactionType,
             duration: webVitalsEvent.duration,
             eventNames: [],
-            phases: webVitalsEvent.phases,
+            subparts: webVitalsEvent.subparts,
             startTime: webVitalsEvent.startTime,
             nextPaintTime: webVitalsEvent.nextPaintTime,
             longAnimationFrameTimings: webVitalsEvent.longAnimationFrameEntries,
@@ -610,12 +610,12 @@ export interface MetricValue {
 }
 
 export interface LcpValue extends MetricValue {
-  phases: Spec.LcpPhases;
+  subparts: Spec.LcpSubparts;
   nodeRef?: SDK.DOMModel.DOMNode;
 }
 
 export interface InpValue extends MetricValue {
-  phases: Spec.InpPhases;
+  subparts: Spec.InpSubparts;
   interactionId: InteractionId;
 }
 
@@ -636,7 +636,7 @@ export interface Interaction {
   duration: number;
   startTime: number;
   nextPaintTime: number;
-  phases: Spec.InpPhases;
+  subparts: Spec.InpSubparts;
   longAnimationFrameTimings: Spec.PerformanceLongAnimationFrameTimingJSON[];
   nodeRef?: SDK.DOMModel.DOMNode;
 }

package/front_end/models/live-metrics/web-vitals-injected/spec/spec.ts

@@ -18,14 +18,14 @@ export function getUniqueLayoutShiftId(entry: LayoutShift): UniqueLayoutShiftId
   return `layout-shift-${entry.value}-${entry.startTime}`;
 }
 
-export interface LcpPhases {
+export interface LcpSubparts {
   timeToFirstByte: Trace.Types.Timing.Milli;
   resourceLoadDelay: Trace.Types.Timing.Milli;
   resourceLoadTime: Trace.Types.Timing.Milli;
   elementRenderDelay: Trace.Types.Timing.Milli;
 }
 
-export interface InpPhases {
+export interface InpSubparts {
   inputDelay: Trace.Types.Timing.Milli;
   processingDuration: Trace.Types.Timing.Milli;
   presentationDelay: Trace.Types.Timing.Milli;
@@ -34,7 +34,7 @@ export interface InpPhases {
 export interface LcpChangeEvent {
   name: 'LCP';
   value: Trace.Types.Timing.Milli;
-  phases: LcpPhases;
+  subparts: LcpSubparts;
   startedHidden: boolean;
   nodeIndex?: number;
 }
@@ -49,7 +49,7 @@ export interface InpChangeEvent {
   name: 'INP';
   value: Trace.Types.Timing.Milli;
   interactionType: INPAttribution['interactionType'];
-  phases: InpPhases;
+  subparts: InpSubparts;
   startTime: number;
   entryGroupId: InteractionEntryGroupId;
 }
@@ -95,7 +95,7 @@ export interface InteractionEntryEvent {
   startTime: number;
   nextPaintTime: number;
   duration: Trace.Types.Timing.Milli;
-  phases: InpPhases;
+  subparts: InpSubparts;
   nodeIndex?: number;
   longAnimationFrameEntries: PerformanceLongAnimationFrameTimingJSON[];
 }

package/front_end/models/live-metrics/web-vitals-injected/web-vitals-injected.ts

@@ -182,7 +182,7 @@ function initialize(): void {
       name: 'LCP',
       value: metric.value as Trace.Types.Timing.Milli,
       startedHidden: Boolean(startedHidden),
-      phases: {
+      subparts: {
         timeToFirstByte: metric.attribution.timeToFirstByte as Trace.Types.Timing.Milli,
         resourceLoadDelay: metric.attribution.resourceLoadDelay as Trace.Types.Timing.Milli,
         resourceLoadTime: metric.attribution.resourceLoadDuration as Trace.Types.Timing.Milli,
@@ -213,7 +213,7 @@ function initialize(): void {
     const event: Spec.InteractionEntryEvent = {
       name: 'InteractionEntry',
       duration: interaction.value as Trace.Types.Timing.Milli,
-      phases: {
+      subparts: {
         inputDelay: interaction.attribution.inputDelay as Trace.Types.Timing.Milli,
         processingDuration: interaction.attribution.processingDuration as Trace.Types.Timing.Milli,
         presentationDelay: interaction.attribution.presentationDelay as Trace.Types.Timing.Milli,
@@ -238,7 +238,7 @@ function initialize(): void {
     const event: Spec.InpChangeEvent = {
       name: 'INP',
       value: metric.value as Trace.Types.Timing.Milli,
-      phases: {
+      subparts: {
         inputDelay: metric.attribution.inputDelay as Trace.Types.Timing.Milli,
         processingDuration: metric.attribution.processingDuration as Trace.Types.Timing.Milli,
         presentationDelay: metric.attribution.presentationDelay as Trace.Types.Timing.Milli,

package/front_end/models/logs/LogManager.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import type * 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';
 
@@ -11,19 +12,33 @@ import {NetworkLog} from './NetworkLog.js';
 
 const modelToEventListeners = new WeakMap<SDK.LogModel.LogModel, Common.EventTarget.EventDescriptor[]>();
 
-let instance: LogManager|null = null;
-
 export class LogManager implements SDK.TargetManager.SDKModelObserver<SDK.LogModel.LogModel> {
-  private constructor() {
-    SDK.TargetManager.TargetManager.instance().observeModels(SDK.LogModel.LogModel, this);
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #networkLog: NetworkLog;
+
+  constructor(
+      targetManager: SDK.TargetManager.TargetManager,
+      networkLog: NetworkLog,
+  ) {
+    this.#targetManager = targetManager;
+    this.#networkLog = networkLog;
+    this.#targetManager.observeModels(SDK.LogModel.LogModel, this);
   }
 
   static instance({forceNew}: {forceNew: boolean} = {forceNew: false}): LogManager {
-    if (!instance || forceNew) {
-      instance = new LogManager();
+    if (!Root.DevToolsContext.globalInstance().has(LogManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(LogManager,
+                                                new LogManager(
+                                                    SDK.TargetManager.TargetManager.instance(),
+                                                    NetworkLog.instance(),
+                                                    ));
     }
 
-    return instance;
+    return Root.DevToolsContext.globalInstance().get(LogManager);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(LogManager);
   }
 
   modelAdded(logModel: SDK.LogModel.LogModel): void {
@@ -56,7 +71,7 @@ export class LogManager implements SDK.TargetManager.SDKModelObserver<SDK.LogMod
         target.model(SDK.RuntimeModel.RuntimeModel), entry.source, entry.level, entry.text, details);
 
     if (entry.networkRequestId) {
-      NetworkLog.instance().associateConsoleMessageWithRequest(consoleMessage, entry.networkRequestId);
+      this.#networkLog.associateConsoleMessageWithRequest(consoleMessage, entry.networkRequestId);
     }
 
     const consoleModel = target.model(SDK.ConsoleModel.ConsoleModel);
@@ -66,11 +81,11 @@ export class LogManager implements SDK.TargetManager.SDKModelObserver<SDK.LogMod
       // user can see messages from the worker which has been already destroyed.
       // When opening DevTools, give us some time to connect to the worker and
       // not report the message twice if the worker is still alive.
-      if (SDK.TargetManager.TargetManager.instance().targetById(workerId)) {
+      if (this.#targetManager.targetById(workerId)) {
         return;
       }
       window.setTimeout(() => {
-        if (!SDK.TargetManager.TargetManager.instance().targetById(workerId)) {
+        if (!this.#targetManager.targetById(workerId)) {
           consoleModel?.addMessage(consoleMessage);
         }
       }, 1000);

package/front_end/models/logs/NetworkLog.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../core/common/common.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 * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
@@ -18,8 +19,6 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('models/logs/NetworkLog.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
-let networkLogInstance: NetworkLog|undefined;
-
 export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDK.TargetManager.SDKModelObserver<SDK.NetworkManager.NetworkManager> {
   #requests: SDK.NetworkRequest.NetworkRequest[] = [];
@@ -32,15 +31,21 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
   readonly #modelListeners = new WeakMap<SDK.NetworkManager.NetworkManager, Common.EventTarget.EventDescriptor[]>();
   readonly #initiatorData = new WeakMap<SDK.NetworkRequest.NetworkRequest, InitiatorData>();
   #isRecording = true;
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #settings: Common.Settings.Settings;
 
-  constructor() {
+  constructor(
+      targetManager: SDK.TargetManager.TargetManager = SDK.TargetManager.TargetManager.instance(),
+      settings: Common.Settings.Settings = Common.Settings.Settings.instance(),
+  ) {
     super();
+    this.#targetManager = targetManager;
+    this.#settings = settings;
 
-    SDK.TargetManager.TargetManager.instance().observeModels(SDK.NetworkManager.NetworkManager, this);
-    const recordLogSetting: Common.Settings.Setting<boolean> =
-        Common.Settings.Settings.instance().moduleSetting('network-log.record-log');
+    this.#targetManager.observeModels(SDK.NetworkManager.NetworkManager, this);
+    const recordLogSetting: Common.Settings.Setting<boolean> = this.#settings.moduleSetting('network-log.record-log');
     recordLogSetting.addChangeListener(() => {
-      const preserveLogSetting = Common.Settings.Settings.instance().moduleSetting('network-log.preserve-log');
+      const preserveLogSetting = this.#settings.moduleSetting('network-log.preserve-log');
       if (!preserveLogSetting.get() && recordLogSetting.get()) {
         this.reset(true);
       }
@@ -49,14 +54,15 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
   }
 
   static instance(): NetworkLog {
-    if (!networkLogInstance) {
-      networkLogInstance = new NetworkLog();
+    if (!Root.DevToolsContext.globalInstance().has(NetworkLog)) {
+      Root.DevToolsContext.globalInstance().set(NetworkLog, new NetworkLog());
     }
-    return networkLogInstance;
+
+    return Root.DevToolsContext.globalInstance().get(NetworkLog);
   }
 
   static removeInstance(): void {
-    networkLogInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(NetworkLog);
   }
 
   modelAdded(networkManager: SDK.NetworkManager.NetworkManager): void {
@@ -102,11 +108,10 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
     }
     this.#isRecording = enabled;
     if (enabled) {
-      SDK.TargetManager.TargetManager.instance().observeModels(SDK.NetworkManager.NetworkManager, this);
+      this.#targetManager.observeModels(SDK.NetworkManager.NetworkManager, this);
     } else {
-      SDK.TargetManager.TargetManager.instance().unobserveModels(SDK.NetworkManager.NetworkManager, this);
-      SDK.TargetManager.TargetManager.instance()
-          .models(SDK.NetworkManager.NetworkManager)
+      this.#targetManager.unobserveModels(SDK.NetworkManager.NetworkManager, this);
+      this.#targetManager.models(SDK.NetworkManager.NetworkManager)
           .forEach(this.removeNetworkManagerListeners.bind(this));
     }
   }
@@ -289,7 +294,7 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
   }
 
   private willReloadPage(): void {
-    if (!Common.Settings.Settings.instance().moduleSetting('network-log.preserve-log').get()) {
+    if (!this.#settings.moduleSetting('network-log.preserve-log').get()) {
       this.reset(true);
     }
   }
@@ -310,7 +315,7 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
       return;
     }
 
-    const preserveLog = Common.Settings.Settings.instance().moduleSetting('network-log.preserve-log').get();
+    const preserveLog = this.#settings.moduleSetting('network-log.preserve-log').get();
 
     const oldRequests = this.#requests;
     const oldManagerRequests =
@@ -501,8 +506,8 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
     this.#requestsSet.clear();
     this.#requestsMap.clear();
     this.#unresolvedPreflightRequests.clear();
-    const managers = new Set<SDK.NetworkManager.NetworkManager>(
-        SDK.TargetManager.TargetManager.instance().models(SDK.NetworkManager.NetworkManager));
+    const managers =
+        new Set<SDK.NetworkManager.NetworkManager>(this.#targetManager.models(SDK.NetworkManager.NetworkManager));
     for (const manager of this.#pageLoadForManager.keys()) {
       if (!managers.has(manager)) {
         this.#pageLoadForManager.delete(manager);

package/front_end/models/persistence/AutomaticFileSystemWorkspaceBinding.ts

@@ -141,14 +141,23 @@ export class FileSystem implements Workspace.Workspace.Project {
     return [];
   }
 
-  async findFilesMatchingSearchRequest(
-      _searchConfig: Workspace.SearchConfig.SearchConfig,
-      _filesMatchingFileQuery: Workspace.UISourceCode.UISourceCode[],
-      _progress: Common.Progress.Progress): Promise<Map<Workspace.UISourceCode.UISourceCode, SearchMatch[]|null>> {
+  async findFilesMatchingSearchRequest(_searchConfig: Workspace.SearchConfig.SearchConfig,
+                                       _filesMatchingFileQuery: Workspace.UISourceCode.UISourceCode[],
+                                       progress: Common.Progress.Progress):
+      Promise<Map<Workspace.UISourceCode.UISourceCode, SearchMatch[]|null>> {
+    // Defer completion to the next microtask to avoid triggering premature
+    // completion events in CompositeProgress setup loops.
+    await Promise.resolve();
+    progress.done = true;
     return new Map();
   }
 
-  indexContent(_progress: Common.Progress.Progress): void {
+  indexContent(progress: Common.Progress.Progress): void {
+    // Defer completion to the next microtask to avoid triggering premature
+    // completion events in CompositeProgress setup loops.
+    queueMicrotask(() => {
+      progress.done = true;
+    });
   }
 
   uiSourceCodeForURL(_url: Platform.DevToolsPath.UrlString): Workspace.UISourceCode.UISourceCode|null {

package/front_end/models/persistence/IsolatedFileSystem.ts

@@ -58,29 +58,27 @@ export class IsolatedFileSystem extends PlatformFileSystem {
   readonly #initialGitFolders = new Set<Platform.DevToolsPath.EncodedPathString>();
   private readonly fileLocks = new Map<Platform.DevToolsPath.EncodedPathString, Promise<unknown>>();
 
-  constructor(
-      manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
-      embedderPath: Platform.DevToolsPath.RawPathString, domFileSystem: FileSystem, type: PlatformFileSystemType,
-      automatic: boolean) {
+  constructor(manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
+              embedderPath: Platform.DevToolsPath.RawPathString, domFileSystem: FileSystem,
+              type: PlatformFileSystemType, automatic: boolean, settings: Common.Settings.Settings) {
     super(path, type, automatic);
     this.manager = manager;
     this.#embedderPath = embedderPath;
     this.domFileSystem = domFileSystem;
-    this.excludedFoldersSetting =
-        Common.Settings.Settings.instance().createLocalSetting('workspace-excluded-folders', {});
+    this.excludedFoldersSetting = settings.createLocalSetting('workspace-excluded-folders', {});
     this.#excludedFolders = new Set(this.excludedFoldersSetting.get()[path] || []);
   }
 
-  static async create(
-      manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
-      embedderPath: Platform.DevToolsPath.RawPathString, type: PlatformFileSystemType, name: string, rootURL: string,
-      automatic: boolean): Promise<IsolatedFileSystem|null> {
+  static async create(manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
+                      embedderPath: Platform.DevToolsPath.RawPathString, type: PlatformFileSystemType, name: string,
+                      rootURL: string, automatic: boolean,
+                      settings: Common.Settings.Settings): Promise<IsolatedFileSystem|null> {
     const domFileSystem = Host.InspectorFrontendHost.InspectorFrontendHostInstance.isolatedFileSystem(name, rootURL);
     if (!domFileSystem) {
       return null;
     }
 
-    const fileSystem = new IsolatedFileSystem(manager, path, embedderPath, domFileSystem, type, automatic);
+    const fileSystem = new IsolatedFileSystem(manager, path, embedderPath, domFileSystem, type, automatic, settings);
     return await fileSystem.initializeFilePaths().then(() => fileSystem).catch(error => {
       console.error(error);
       return null;

package/front_end/models/persistence/IsolatedFileSystemManager.ts

@@ -33,8 +33,10 @@ 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;
+  private constructor(settings: Common.Settings.Settings = Common.Settings.Settings.instance()) {
     super();
+    this.#settings = settings;
 
     this.#fileSystems = new Map();
     this.callbacks = new Map();
@@ -90,7 +92,7 @@ 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;
@@ -160,7 +162,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|

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);
   }