chrome-devtools-frontend 1.0.1603822 → 1.0.1605219

package/front_end/core/sdk/DOMDebuggerModel.ts

@@ -4,7 +4,7 @@
 
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
-import * as Common from '../common/common.js';
+import type * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 
 import {CategorizedBreakpoint, Category} from './CategorizedBreakpoint.js';
@@ -38,7 +38,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
     this.#domModel.addEventListener(DOMModelEvents.NodeRemoved, this.nodeRemoved, this);
 
     this.#domBreakpoints = [];
-    this.#domBreakpointsSetting = Common.Settings.Settings.instance().createLocalSetting('dom-breakpoints', []);
+    this.#domBreakpointsSetting = this.target().targetManager().settings.createLocalSetting('dom-breakpoints', []);
     if (this.#domModel.existingDocument()) {
       void this.documentUpdated();
     }
@@ -498,9 +498,11 @@ export class CSPViolationBreakpoint extends CategorizedBreakpoint {
 
 export class DOMEventListenerBreakpoint extends CategorizedBreakpoint {
   readonly eventTargetNames: string[];
-  constructor(eventName: string, eventTargetNames: string[], category: Category) {
+  readonly #targetManager: TargetManager;
+  constructor(eventName: string, eventTargetNames: string[], category: Category, targetManager: TargetManager) {
     super(category, eventName);
     this.eventTargetNames = eventTargetNames;
+    this.#targetManager = targetManager;
   }
 
   override setEnabled(enabled: boolean): void {
@@ -508,7 +510,7 @@ export class DOMEventListenerBreakpoint extends CategorizedBreakpoint {
       return;
     }
     super.setEnabled(enabled);
-    for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
+    for (const model of this.#targetManager.models(DOMDebuggerModel)) {
       this.updateOnModel(model);
     }
   }
@@ -534,9 +536,11 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
 
   readonly #cspViolationsToBreakOn: CSPViolationBreakpoint[] = [];
   readonly #eventListenerBreakpoints: DOMEventListenerBreakpoint[] = [];
+  readonly #targetManager: TargetManager;
 
-  constructor() {
-    this.#xhrBreakpointsSetting = Common.Settings.Settings.instance().createLocalSetting('xhr-breakpoints', []);
+  constructor(targetManager: TargetManager = TargetManager.instance()) {
+    this.#targetManager = targetManager;
+    this.#xhrBreakpointsSetting = this.#targetManager.settings.createLocalSetting('xhr-breakpoints', []);
     for (const breakpoint of this.#xhrBreakpointsSetting.get()) {
       this.#xhrBreakpoints.set(breakpoint.url, breakpoint.enabled);
     }
@@ -659,15 +663,16 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
         Category.XHR, ['readystatechange', 'load', 'loadstart', 'loadend', 'abort', 'error', 'progress', 'timeout'],
         ['xmlhttprequest', 'xmlhttprequestupload']);
 
-    TargetManager.instance().observeModels(DOMDebuggerModel, this);
+    this.#targetManager.observeModels(DOMDebuggerModel, this);
   }
 
   static instance(opts: {
     forceNew: boolean|null,
+    targetManager?: TargetManager,
   } = {forceNew: null}): DOMDebuggerManager {
-    const {forceNew} = opts;
+    const {forceNew, targetManager} = opts;
     if (!domDebuggerManagerInstance || forceNew) {
-      domDebuggerManagerInstance = new DOMDebuggerManager();
+      domDebuggerManagerInstance = new DOMDebuggerManager(targetManager);
     }
 
     return domDebuggerManagerInstance;
@@ -679,7 +684,8 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
 
   private createEventListenerBreakpoints(category: Category, eventNames: string[], eventTargetNames: string[]): void {
     for (const eventName of eventNames) {
-      this.#eventListenerBreakpoints.push(new DOMEventListenerBreakpoint(eventName, eventTargetNames, category));
+      this.#eventListenerBreakpoints.push(
+          new DOMEventListenerBreakpoint(eventName, eventTargetNames, category, this.#targetManager));
     }
   }
 
@@ -710,7 +716,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
 
   updateCSPViolationBreakpoints(): void {
     const violationTypes = this.#cspViolationsToBreakOn.filter(v => v.enabled()).map(v => v.type());
-    for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
+    for (const model of this.#targetManager.models(DOMDebuggerModel)) {
       this.updateCSPViolationBreakpointsForModel(model, violationTypes);
     }
   }
@@ -735,7 +741,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   addXHRBreakpoint(url: string, enabled: boolean): void {
     this.#xhrBreakpoints.set(url, enabled);
     if (enabled) {
-      for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
+      for (const model of this.#targetManager.models(DOMDebuggerModel)) {
         void model.agent.invoke_setXHRBreakpoint({url});
       }
     }
@@ -746,7 +752,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
     const enabled = this.#xhrBreakpoints.get(url);
     this.#xhrBreakpoints.delete(url);
     if (enabled) {
-      for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
+      for (const model of this.#targetManager.models(DOMDebuggerModel)) {
         void model.agent.invoke_removeXHRBreakpoint({url});
       }
     }
@@ -755,7 +761,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
 
   toggleXHRBreakpoint(url: string, enabled: boolean): void {
     this.#xhrBreakpoints.set(url, enabled);
-    for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
+    for (const model of this.#targetManager.models(DOMDebuggerModel)) {
       if (enabled) {
         void model.agent.invoke_setXHRBreakpoint({url});
       } else {

package/front_end/core/sdk/DOMModel.ts

@@ -190,7 +190,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
   /**
    * Set if a DOMNode is ad related.
    */
-  #isAdRelatedInternal = false;
+  #adProvenance?: Protocol.Network.AdProvenance;
 
   constructor(domModel: DOMModel) {
     super();
@@ -292,7 +292,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     this.setPseudoElements(payload.pseudoElements);
 
     if (payload.adProvenance) {
-      this.#isAdRelatedInternal = true;
+      this.#adProvenance = payload.adProvenance;
     }
 
     if (this.#nodeType === Node.ELEMENT_NODE) {
@@ -331,21 +331,24 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     return this.#topLayerIndex;
   }
 
-  isAdRelatedNode(): boolean {
-    // For iframes, we rely on `AdFrameType` to preserve legacy behavior and
-    // prevent regressions.
-    //
-    // TODO(yaoxia): Deprecate the iframe-specific logic and consolidate
-    // everything to use `#isAdRelatedInternal`.
-    if (this.isIframe() && this.#frameOwnerFrameId) {
-      const frame = FrameManager.instance().getFrame(this.#frameOwnerFrameId);
-      if (!frame) {
-        return false;
-      }
-      return frame.adFrameType() !== Protocol.Page.AdFrameType.None;
+  adProvenance(): Protocol.Network.AdProvenance|undefined {
+    if (this.#adProvenance !== undefined) {
+      return this.#adProvenance;
+    }
+
+    // AdProvenance can be unavailable for deeply nested OOPIF ad iframes
+    // (crbug.com/421202278). We rely on `AdFrameType` as a fallback.
+    if (!this.isIframe() || !this.#frameOwnerFrameId) {
+      return undefined;
     }
 
-    return this.#isAdRelatedInternal;
+    const frame = FrameManager.instance().getFrame(this.#frameOwnerFrameId);
+    if (frame && frame.adFrameType() !== Protocol.Page.AdFrameType.None) {
+      // The frame is ad-related, but provenance information is unavailable.
+      return {};
+    }
+
+    return undefined;
   }
 
   isRootNode(): boolean {
@@ -425,8 +428,8 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     }
   }
 
-  setIsAdRelated(isAdRelated: boolean): void {
-    this.#isAdRelatedInternal = isAdRelated;
+  setIsAdRelated(adProvenance?: Protocol.Network.AdProvenance): void {
+    this.#adProvenance = adProvenance;
     this.dispatchEventToListeners(DOMNodeEvents.AD_RELATED_STATE_UPDATED);
   }
 
@@ -1476,8 +1479,8 @@ export class DOMModel extends SDKModel<EventTypes> {
     return this.target().model(OverlayModel) as OverlayModel;
   }
 
-  static cancelSearch(): void {
-    for (const domModel of TargetManager.instance().models(DOMModel)) {
+  static cancelSearch(targetManager: TargetManager = TargetManager.instance()): void {
+    for (const domModel of targetManager.models(DOMModel)) {
       domModel.cancelSearch();
     }
   }
@@ -1832,12 +1835,11 @@ export class DOMModel extends SDKModel<EventTypes> {
   }
 
   adRelatedStateUpdated(nodeId: Protocol.DOM.NodeId, adProvenance?: Protocol.Network.AdProvenance): void {
-    const isAdRelated = adProvenance !== undefined;
     const node = this.nodeForId(nodeId);
-    if (!node || node.isAdRelatedNode() === isAdRelated) {
+    if (!node) {
       return;
     }
-    node.setIsAdRelated(isAdRelated);
+    node.setIsAdRelated(adProvenance);
   }
 
   affectedByStartingStylesFlagUpdated(nodeId: Protocol.DOM.NodeId, affectedByStartingStyles: boolean): void {

package/front_end/core/sdk/DebuggerModel.ts

@@ -173,30 +173,19 @@ export class DebuggerModel extends SDKModel<EventTypes> {
         (compiledURL, sourceMappingURL, payload, script) =>
             new SourceMap(compiledURL, sourceMappingURL, payload, script));
 
-    Common.Settings.Settings.instance()
-        .moduleSetting('pause-on-exception-enabled')
-        .addChangeListener(this.pauseOnExceptionStateChanged, this);
-    Common.Settings.Settings.instance()
-        .moduleSetting('pause-on-caught-exception')
-        .addChangeListener(this.pauseOnExceptionStateChanged, this);
-    Common.Settings.Settings.instance()
-        .moduleSetting('pause-on-uncaught-exception')
-        .addChangeListener(this.pauseOnExceptionStateChanged, this);
-    Common.Settings.Settings.instance()
-        .moduleSetting('disable-async-stack-traces')
-        .addChangeListener(this.asyncStackTracesStateChanged, this);
-    Common.Settings.Settings.instance()
-        .moduleSetting('breakpoints-active')
-        .addChangeListener(this.breakpointsActiveChanged, this);
+    const settings = this.target().targetManager().settings;
+    settings.moduleSetting('pause-on-exception-enabled').addChangeListener(this.pauseOnExceptionStateChanged, this);
+    settings.moduleSetting('pause-on-caught-exception').addChangeListener(this.pauseOnExceptionStateChanged, this);
+    settings.moduleSetting('pause-on-uncaught-exception').addChangeListener(this.pauseOnExceptionStateChanged, this);
+    settings.moduleSetting('disable-async-stack-traces').addChangeListener(this.asyncStackTracesStateChanged, this);
+    settings.moduleSetting('breakpoints-active').addChangeListener(this.breakpointsActiveChanged, this);
 
     if (!target.suspended()) {
       void this.enableDebugger();
     }
 
-    this.#sourceMapManager.setEnabled(
-        Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get());
-    Common.Settings.Settings.instance()
-        .moduleSetting('js-source-maps-enabled')
+    this.#sourceMapManager.setEnabled(settings.moduleSetting('js-source-maps-enabled').get());
+    settings.moduleSetting('js-source-maps-enabled')
         .addChangeListener(event => this.#sourceMapManager.setEnabled((event.data as boolean)));
 
     const resourceTreeModel = (target.model(ResourceTreeModel) as ResourceTreeModel);
@@ -273,7 +262,8 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     }
     this.pauseOnExceptionStateChanged();
     void this.asyncStackTracesStateChanged();
-    if (!Common.Settings.Settings.instance().moduleSetting('breakpoints-active').get()) {
+    const settings = this.target().targetManager().settings;
+    if (!settings.moduleSetting('breakpoints-active').get()) {
       this.breakpointsActiveChanged();
     }
     this.dispatchEventToListeners(Events.DebuggerWasEnabled, this);
@@ -364,11 +354,11 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   }
 
   private pauseOnExceptionStateChanged(): void {
-    const pauseOnCaughtEnabled = Common.Settings.Settings.instance().moduleSetting('pause-on-caught-exception').get();
+    const settings = this.target().targetManager().settings;
+    const pauseOnCaughtEnabled = settings.moduleSetting('pause-on-caught-exception').get();
     let state: Protocol.Debugger.SetPauseOnExceptionsRequestState;
 
-    const pauseOnUncaughtEnabled =
-        Common.Settings.Settings.instance().moduleSetting('pause-on-uncaught-exception').get();
+    const pauseOnUncaughtEnabled = settings.moduleSetting('pause-on-uncaught-exception').get();
     if (pauseOnCaughtEnabled && pauseOnUncaughtEnabled) {
       state = Protocol.Debugger.SetPauseOnExceptionsRequestState.All;
     } else if (pauseOnCaughtEnabled) {
@@ -383,15 +373,15 @@ export class DebuggerModel extends SDKModel<EventTypes> {
 
   private asyncStackTracesStateChanged(): Promise<Protocol.ProtocolResponseWithError> {
     const maxAsyncStackChainDepth = 32;
-    const enabled =
-        !Common.Settings.Settings.instance().moduleSetting('disable-async-stack-traces').get() && this.#debuggerEnabled;
+    const settings = this.target().targetManager().settings;
+    const enabled = !settings.moduleSetting('disable-async-stack-traces').get() && this.#debuggerEnabled;
     const maxDepth = enabled ? maxAsyncStackChainDepth : 0;
     return this.agent.invoke_setAsyncCallStackDepth({maxDepth});
   }
 
   private breakpointsActiveChanged(): void {
-    void this.agent.invoke_setBreakpointsActive(
-        {active: Common.Settings.Settings.instance().moduleSetting('breakpoints-active').get()});
+    const settings = this.target().targetManager().settings;
+    void this.agent.invoke_setBreakpointsActive({active: settings.moduleSetting('breakpoints-active').get()});
   }
 
   setComputeAutoStepRangesCallback(callback: ((arg0: StepMode, arg1: CallFrame) => Promise<LocationRange[]>)|null):
@@ -872,15 +862,10 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     if (this.#debuggerId) {
       debuggerIdToModel.delete(this.#debuggerId);
     }
-    Common.Settings.Settings.instance()
-        .moduleSetting('pause-on-exception-enabled')
-        .removeChangeListener(this.pauseOnExceptionStateChanged, this);
-    Common.Settings.Settings.instance()
-        .moduleSetting('pause-on-caught-exception')
-        .removeChangeListener(this.pauseOnExceptionStateChanged, this);
-    Common.Settings.Settings.instance()
-        .moduleSetting('disable-async-stack-traces')
-        .removeChangeListener(this.asyncStackTracesStateChanged, this);
+    const settings = this.target().targetManager().settings;
+    settings.moduleSetting('pause-on-exception-enabled').removeChangeListener(this.pauseOnExceptionStateChanged, this);
+    settings.moduleSetting('pause-on-caught-exception').removeChangeListener(this.pauseOnExceptionStateChanged, this);
+    settings.moduleSetting('disable-async-stack-traces').removeChangeListener(this.asyncStackTracesStateChanged, this);
   }
 
   override async suspendModel(): Promise<void> {

package/front_end/core/sdk/EmulationModel.ts

@@ -4,7 +4,6 @@
 
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
-import * as Common from '../common/common.js';
 
 import {CSSModel} from './CSSModel.js';
 import {MultitargetNetworkManager} from './NetworkManager.js';
@@ -50,7 +49,8 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       }, this);
     }
 
-    const disableJavascriptSetting = Common.Settings.Settings.instance().moduleSetting('java-script-disabled');
+    const settings = this.target().targetManager().settings;
+    const disableJavascriptSetting = settings.moduleSetting('java-script-disabled');
     disableJavascriptSetting.addChangeListener(
         async () =>
             await this.#emulationAgent.invoke_setScriptExecutionDisabled({value: disableJavascriptSetting.get()}));
@@ -58,14 +58,14 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       void this.#emulationAgent.invoke_setScriptExecutionDisabled({value: true});
     }
 
-    const touchSetting = Common.Settings.Settings.instance().moduleSetting('emulation.touch');
+    const touchSetting = settings.moduleSetting('emulation.touch');
     touchSetting.addChangeListener(() => {
       const settingValue = touchSetting.get();
 
       void this.overrideEmulateTouch(settingValue === 'force');
     });
 
-    const idleDetectionSetting = Common.Settings.Settings.instance().moduleSetting('emulation.idle-detection');
+    const idleDetectionSetting = settings.moduleSetting('emulation.idle-detection');
     idleDetectionSetting.addChangeListener(async () => {
       const settingValue = idleDetectionSetting.get();
       if (settingValue === 'none') {
@@ -80,7 +80,7 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       await this.setIdleOverride(emulationParams);
     });
 
-    const cpuPressureDetectionSetting = Common.Settings.Settings.instance().moduleSetting('emulation.cpu-pressure');
+    const cpuPressureDetectionSetting = settings.moduleSetting('emulation.cpu-pressure');
     cpuPressureDetectionSetting.addChangeListener(async () => {
       const settingValue = cpuPressureDetectionSetting.get();
 
@@ -98,21 +98,19 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       await this.setPressureStateOverride(settingValue);
     });
 
-    const mediaTypeSetting = Common.Settings.Settings.instance().moduleSetting<string>('emulated-css-media');
-    const mediaFeatureColorGamutSetting =
-        Common.Settings.Settings.instance().moduleSetting<string>('emulated-css-media-feature-color-gamut');
+    const mediaTypeSetting = settings.moduleSetting<string>('emulated-css-media');
+    const mediaFeatureColorGamutSetting = settings.moduleSetting<string>('emulated-css-media-feature-color-gamut');
     const mediaFeaturePrefersColorSchemeSetting =
-        Common.Settings.Settings.instance().moduleSetting<string>('emulated-css-media-feature-prefers-color-scheme');
-    const mediaFeatureForcedColorsSetting =
-        Common.Settings.Settings.instance().moduleSetting('emulated-css-media-feature-forced-colors');
+        settings.moduleSetting<string>('emulated-css-media-feature-prefers-color-scheme');
+    const mediaFeatureForcedColorsSetting = settings.moduleSetting('emulated-css-media-feature-forced-colors');
     const mediaFeaturePrefersContrastSetting =
-        Common.Settings.Settings.instance().moduleSetting<string>('emulated-css-media-feature-prefers-contrast');
+        settings.moduleSetting<string>('emulated-css-media-feature-prefers-contrast');
     const mediaFeaturePrefersReducedDataSetting =
-        Common.Settings.Settings.instance().moduleSetting<string>('emulated-css-media-feature-prefers-reduced-data');
-    const mediaFeaturePrefersReducedTransparencySetting = Common.Settings.Settings.instance().moduleSetting<string>(
-        'emulated-css-media-feature-prefers-reduced-transparency');
+        settings.moduleSetting<string>('emulated-css-media-feature-prefers-reduced-data');
+    const mediaFeaturePrefersReducedTransparencySetting =
+        settings.moduleSetting<string>('emulated-css-media-feature-prefers-reduced-transparency');
     const mediaFeaturePrefersReducedMotionSetting =
-        Common.Settings.Settings.instance().moduleSetting<string>('emulated-css-media-feature-prefers-reduced-motion');
+        settings.moduleSetting<string>('emulated-css-media-feature-prefers-reduced-motion');
     // Note: this uses a different format than what the CDP API expects,
     // because we want to update these values per media type/feature
     // without having to search the `features` array (inefficient) or
@@ -161,7 +159,7 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
     });
     void this.updateCssMedia();
 
-    const autoDarkModeSetting = Common.Settings.Settings.instance().moduleSetting('emulate-auto-dark-mode');
+    const autoDarkModeSetting = settings.moduleSetting('emulate-auto-dark-mode');
     autoDarkModeSetting.addChangeListener(() => {
       const enabled = autoDarkModeSetting.get();
       mediaFeaturePrefersColorSchemeSetting.setDisabled(enabled);
@@ -174,13 +172,13 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       void this.emulateAutoDarkMode(true);
     }
 
-    const visionDeficiencySetting = Common.Settings.Settings.instance().moduleSetting('emulated-vision-deficiency');
+    const visionDeficiencySetting = settings.moduleSetting('emulated-vision-deficiency');
     visionDeficiencySetting.addChangeListener(() => this.emulateVisionDeficiency(visionDeficiencySetting.get()));
     if (visionDeficiencySetting.get()) {
       void this.emulateVisionDeficiency(visionDeficiencySetting.get());
     }
 
-    const osTextScaleSetting = Common.Settings.Settings.instance().moduleSetting('emulated-os-text-scale');
+    const osTextScaleSetting = settings.moduleSetting('emulated-os-text-scale');
     osTextScaleSetting.addChangeListener(() => {
       void this.emulateOSTextScale(parseFloat(osTextScaleSetting.get()) || undefined);
     });
@@ -188,15 +186,15 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       void this.emulateOSTextScale(parseFloat(osTextScaleSetting.get()) || undefined);
     }
 
-    const localFontsDisabledSetting = Common.Settings.Settings.instance().moduleSetting('local-fonts-disabled');
+    const localFontsDisabledSetting = settings.moduleSetting('local-fonts-disabled');
     localFontsDisabledSetting.addChangeListener(() => this.setLocalFontsDisabled(localFontsDisabledSetting.get()));
     if (localFontsDisabledSetting.get()) {
       this.setLocalFontsDisabled(localFontsDisabledSetting.get());
     }
 
-    const avifFormatDisabledSetting = Common.Settings.Settings.instance().moduleSetting('avif-format-disabled');
-    const jpegXlFormatDisabledSetting = Common.Settings.Settings.instance().moduleSetting('jpeg-xl-format-disabled');
-    const webpFormatDisabledSetting = Common.Settings.Settings.instance().moduleSetting('webp-format-disabled');
+    const avifFormatDisabledSetting = settings.moduleSetting('avif-format-disabled');
+    const jpegXlFormatDisabledSetting = settings.moduleSetting('jpeg-xl-format-disabled');
+    const webpFormatDisabledSetting = settings.moduleSetting('webp-format-disabled');
 
     const updateDisabledImageFormats = (): void => {
       const types = [];

package/front_end/core/sdk/EventBreakpointsModel.ts

@@ -56,12 +56,18 @@ export class EventBreakpointsModel extends SDKModel<void> {
  * instrumentation breakpoints in targets that run JS but do not have a DOM.
  **/
 class EventListenerBreakpoint extends CategorizedBreakpoint {
+  readonly #targetManager: TargetManager;
+  constructor(category: Category, name: string, targetManager: TargetManager) {
+    super(category, name);
+    this.#targetManager = targetManager;
+  }
+
   override setEnabled(enabled: boolean): void {
     if (this.enabled() === enabled) {
       return;
     }
     super.setEnabled(enabled);
-    for (const model of TargetManager.instance().models(EventBreakpointsModel)) {
+    for (const model of this.#targetManager.models(EventBreakpointsModel)) {
       this.updateOnModel(model);
     }
   }
@@ -81,8 +87,10 @@ let eventBreakpointManagerInstance: EventBreakpointsManager;
 
 export class EventBreakpointsManager implements SDKModelObserver<EventBreakpointsModel> {
   readonly #eventListenerBreakpoints: EventListenerBreakpoint[] = [];
+  readonly #targetManager: TargetManager;
 
-  constructor() {
+  constructor(targetManager: TargetManager = TargetManager.instance()) {
+    this.#targetManager = targetManager;
     this.createInstrumentationBreakpoints(Category.AUCTION_WORKLET, [
       InstrumentationNames.BEFORE_BIDDER_WORKLET_BIDDING_START,
       InstrumentationNames.BEFORE_BIDDER_WORKLET_REPORTING_START,
@@ -135,15 +143,16 @@ export class EventBreakpointsManager implements SDKModelObserver<EventBreakpoint
       InstrumentationNames.AUDIO_CONTEXT_SUSPENDED,
     ]);
 
-    TargetManager.instance().observeModels(EventBreakpointsModel, this);
+    this.#targetManager.observeModels(EventBreakpointsModel, this);
   }
 
   static instance(opts: {
     forceNew: boolean|null,
+    targetManager?: TargetManager,
   } = {forceNew: null}): EventBreakpointsManager {
-    const {forceNew} = opts;
+    const {forceNew, targetManager} = opts;
     if (!eventBreakpointManagerInstance || forceNew) {
-      eventBreakpointManagerInstance = new EventBreakpointsManager();
+      eventBreakpointManagerInstance = new EventBreakpointsManager(targetManager);
     }
 
     return eventBreakpointManagerInstance;
@@ -151,7 +160,8 @@ export class EventBreakpointsManager implements SDKModelObserver<EventBreakpoint
 
   private createInstrumentationBreakpoints(category: Category, instrumentationNames: InstrumentationNames[]): void {
     for (const instrumentationName of instrumentationNames) {
-      this.#eventListenerBreakpoints.push(new EventListenerBreakpoint(category, instrumentationName));
+      this.#eventListenerBreakpoints.push(
+          new EventListenerBreakpoint(category, instrumentationName, this.#targetManager));
     }
   }
 

package/front_end/core/sdk/HeapProfilerModel.ts

@@ -11,21 +11,18 @@ import type {RemoteObject} from './RemoteObject.js';
 import {RuntimeModel} from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';
 import {Capability, type Target} from './Target.js';
-import {TargetManager} from './TargetManager.js';
 
 export class HeapProfilerModel extends SDKModel<EventTypes> {
-  #enabled: boolean;
+  #enabled = false;
   readonly #heapProfilerAgent: ProtocolProxyApi.HeapProfilerApi;
   readonly #runtimeModel: RuntimeModel;
-  #samplingProfilerDepth: number;
+  #samplingProfilerDepth = 0;
 
   constructor(target: Target) {
     super(target);
     target.registerHeapProfilerDispatcher(new HeapProfilerDispatcher(this));
-    this.#enabled = false;
     this.#heapProfilerAgent = target.heapProfilerAgent();
     this.#runtimeModel = (target.model(RuntimeModel) as RuntimeModel);
-    this.#samplingProfilerDepth = 0;
   }
 
   debuggerModel(): DebuggerModel {
@@ -107,11 +104,11 @@ export class HeapProfilerModel extends SDKModel<EventTypes> {
   }
 
   async takeHeapSnapshot(heapSnapshotOptions: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise<void> {
-    await TargetManager.instance().suspendAllTargets('heap-snapshot');
+    await this.target().targetManager().suspendAllTargets('heap-snapshot');
     try {
       await this.#heapProfilerAgent.invoke_takeHeapSnapshot(heapSnapshotOptions);
     } finally {
-      await TargetManager.instance().resumeAllTargets();
+      await this.target().targetManager().resumeAllTargets();
     }
   }
 

package/front_end/core/sdk/IsolateManager.ts

@@ -19,18 +19,21 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
   #isolateIdByModel = new Map<RuntimeModel, string|null>();
   #observers = new Set<Observer>();
   #pollId = 0;
+  readonly #targetManager: TargetManager;
 
-  constructor() {
+  constructor(targetManager: TargetManager = TargetManager.instance()) {
     super();
+    this.#targetManager = targetManager;
 
-    TargetManager.instance().observeModels(RuntimeModel, this);
+    this.#targetManager.observeModels(RuntimeModel, this);
   }
 
-  static instance({forceNew}: {
+  static instance({forceNew, targetManager}: {
     forceNew: boolean,
+    targetManager?: TargetManager,
   } = {forceNew: false}): IsolateManager {
     if (!isolateManagerInstance || forceNew) {
-      isolateManagerInstance = new IsolateManager();
+      isolateManagerInstance = new IsolateManager(targetManager);
     }
 
     return isolateManagerInstance;
@@ -67,7 +70,7 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.#isolateIdByModel.set(model, isolateId);
     let isolate = this.#isolates.get(isolateId);
     if (!isolate) {
-      isolate = new Isolate(isolateId);
+      isolate = new Isolate(isolateId, this);
       this.#isolates.set(isolateId, isolate);
     }
     isolate.models().add(model);
@@ -145,9 +148,11 @@ export class Isolate {
   readonly #models: Set<RuntimeModel>;
   #usedHeapSize: number;
   readonly #memoryTrend: MemoryTrend;
+  readonly #manager: IsolateManager;
 
-  constructor(id: string) {
+  constructor(id: string, manager: IsolateManager) {
     this.#id = id;
+    this.#manager = manager;
     this.#models = new Set();
     this.#usedHeapSize = 0;
     const count = MemoryTrendWindowMs / PollIntervalMs;
@@ -179,7 +184,7 @@ export class Isolate {
     }
     this.#usedHeapSize = usage.usedSize + (usage.embedderHeapUsedSize ?? 0) + (usage.backingStorageSize ?? 0);
     this.#memoryTrend.add(this.#usedHeapSize);
-    IsolateManager.instance().dispatchEventToListeners(Events.MEMORY_CHANGED, this);
+    this.#manager.dispatchEventToListeners(Events.MEMORY_CHANGED, this);
   }
 
   samplesCount(): number {