devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/core/sdk/EnhancedTracesParser.ts

@@ -1,515 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as Protocol from '../../generated/protocol.js';
-import * as Common from '../common/common.js';
-import type * as Platform from '../platform/platform.js';
-import {UserVisibleError} from '../platform/platform.js';
-
-import type {
-  HydratingDataPerTarget, RehydratingExecutionContext, RehydratingScript, RehydratingTarget} from
-  './RehydratingObject.js';
-import type {SourceMapV3} from './SourceMap.js';
-import type {TraceObject} from './TraceObject.js';
-
-interface EventBase {
-  cat: string;
-  pid: number;
-  args: {data: object};
-  name: string;
-}
-
-/**
- * While called 'TargetRundown', this event is emitted for each script that is compiled or evaluated.
- * Within EnhancedTraceParser, this event is used to construct targets and execution contexts (and to associate scripts to frames).
- *
- * See `inspector_target_rundown_event::Data` https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/inspector_trace_events.cc;l=1189-1232;drc=48d6f7175422b2c969c14258f9f8d5b196c28d18
- */
-export interface RundownScriptCompiled extends EventBase {
-  cat: 'disabled-by-default-devtools.target-rundown';
-  name: 'ScriptCompiled'|'ModuleEvaluated';
-  args: {
-    data: {
-      frame: Protocol.Page.FrameId,
-      frameType: 'page'|'iframe',
-      url: string,
-      /**
-       * Older traces were a number, but this is an unsigned 64 bit value, so that was a bug.
-       * New traces use string instead. See https://crbug.com/447654178.
-       */
-      isolate: string|number,
-      /** AKA V8ContextToken. https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/inspector_trace_events.cc;l=1229;drc=3c88f61e18b043e70c225d8d57c77832a85e7f58 */
-      v8context: string,
-      origin: string,
-      scriptId: number,
-      /** script->World().isMainWorld() */
-      isDefault?: boolean,
-      contextType?: 'default'|'isolated'|'worker',
-    },
-  };
-}
-/**
- * When profiling starts, all currently loaded scripts are emitted via this event.
- *
- * See `Script::TraceScriptRundown()` https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/script.cc;l=184-220;drc=328f6c467b940f322544567740c9c871064d045c
- */
-export interface RundownScript extends EventBase {
-  cat: 'disabled-by-default-devtools.v8-source-rundown';
-  name: 'ScriptCatchup';
-  args: {
-    data: {
-      /**
-       * Older traces were a number, but this is an unsigned 64 bit value, so that was a bug.
-       * New traces use string instead. See https://crbug.com/447654178.
-       */
-      isolate: string|number,
-      executionContextId: Protocol.Runtime.ExecutionContextId,
-      scriptId: number,
-      isModule: boolean,
-      /** aka HasSourceURLComment */
-      hasSourceUrl: boolean,
-      // These don't actually get set in v8.
-      url?: string,
-      hash?: string,
-      /** value of the sourceURL comment. */
-      sourceUrl?: string,
-      /* value of the sourceMappingURL comment */
-      sourceMapUrl?: string,
-      /** If true, the source map url was a data URL, so the `sourceMapUrl` was removed. */
-      sourceMapUrlElided?: boolean,
-      startLine?: number,
-      startColumn?: number,
-      endLine?: number,
-      endColumn?: number,
-    },
-  };
-}
-
-export interface RundownScriptSource extends EventBase {
-  cat: 'disabled-by-default-devtools.v8-source-rundown-sources';
-  name: 'ScriptCatchup'|'LargeScriptCatchup'|'TooLargeScriptCatchup';
-  args: {
-    data: {
-      isolate: number,
-      scriptId: number,
-      length?: number,
-      sourceText?: string,
-    },
-  };
-}
-
-interface TracingStartedInBrowser extends EventBase {
-  cat: 'disabled-by-default-devtools.timeline';
-  args: {
-    data: {
-      frames: [{
-        frame: Protocol.Page.FrameId,
-        isInPrimaryMainFrame: boolean,
-        isOutermostMainFrame: boolean,
-        parent: Protocol.Page.FrameId,
-        processId: number,
-        url: string,
-        pid: number,
-      }],
-    },
-  };
-}
-
-interface FunctionCall extends EventBase {
-  cat: 'devtools.timeline';
-  args: {
-    data: {
-      frame: Protocol.Page.FrameId,
-      scriptId: Protocol.Runtime.ScriptId,
-      /**
-       * Older traces were a number, but this is an unsigned 64 bit value, so that was a bug.
-       * New traces use string instead. See https://crbug.com/447654178.
-       */
-      isolate?: string|number,
-    },
-  };
-}
-
-export class EnhancedTracesParser {
-  #trace: TraceObject;
-  #scriptRundownEvents: RundownScript[] = [];
-  #scriptToV8Context: Map<string, string> = new Map<string, string>();
-  #scriptToFrame: Map<string, Protocol.Page.FrameId> = new Map<string, Protocol.Page.FrameId>();
-  #scriptToScriptSource: Map<string, string> = new Map<string, string>();
-  #largeScriptToScriptSource: Map<string, string[]> = new Map<string, string[]>();
-  #scriptToSourceLength: Map<string, number> = new Map<string, number>();
-  #targets: RehydratingTarget[] = [];
-  #executionContexts: RehydratingExecutionContext[] = [];
-  #scripts: RehydratingScript[] = [];
-  static readonly enhancedTraceVersion: number = 1;
-
-  constructor(trace: TraceObject) {
-    this.#trace = trace;
-
-    // Initialize with the trace provided.
-    try {
-      this.parseEnhancedTrace();
-    } catch (e) {
-      throw new UserVisibleError.UserVisibleError(e);
-    }
-  }
-
-  parseEnhancedTrace(): void {
-    for (const event of this.#trace.traceEvents) {
-      if (this.isTracingStartedInBrowser(event)) {
-        // constructs all targets by devtools.timeline TracingStartedInBrowser
-        const data = event.args?.data;
-        for (const frame of data.frames) {
-          if (frame.url === 'about:blank') {
-            continue;
-          }
-          const frameId = frame.frame as string as Protocol.Target.TargetID;
-          if (!this.#targets.find(target => target.targetId === frameId)) {
-            const frameType = frame.isOutermostMainFrame ? 'page' : 'iframe';
-            this.#targets.push({
-              targetId: frameId,
-              type: frameType,
-              pid: frame.processId,
-              url: frame.url,
-            });
-          }
-        }
-      } else if (this.isFunctionCallEvent(event)) {
-        // constructs all script to frame mapping with devtools.timeline FunctionCall
-        const data = event.args?.data;
-        if (data.isolate) {
-          this.#scriptToFrame.set(this.getScriptIsolateId(data.isolate, data.scriptId), data.frame);
-        }
-      } else if (this.isRundownScriptCompiled(event)) {
-        // Set up script to v8 context mapping
-        const data = event.args?.data;
-        this.#scriptToV8Context.set(this.getScriptIsolateId(data.isolate, data.scriptId), data.v8context);
-        this.#scriptToFrame.set(this.getScriptIsolateId(data.isolate, data.scriptId), data.frame);
-        // All the targets should've been added by the TracingStartedInBrowser event, but just in case we're missing some there
-        const frameId = data.frame as string as Protocol.Target.TargetID;
-        if (!this.#targets.find(target => target.targetId === frameId)) {
-          this.#targets.push({
-            targetId: frameId,
-            type: data.frameType,
-            isolate: String(data.isolate),
-            pid: event.pid,
-            url: data.url,
-          });
-        }
-        // Add execution context, need to put back execution context id with info from other traces
-        if (!this.#executionContexts.find(executionContext => executionContext.v8Context === data.v8context)) {
-          this.#executionContexts.push({
-            id: -1 as Protocol.Runtime.ExecutionContextId,
-            origin: data.origin,
-            v8Context: data.v8context,
-            auxData: {
-              frameId: data.frame,
-              isDefault: data.isDefault,
-              type: data.contextType,
-            },
-            isolate: String(data.isolate),
-            name: data.origin,
-            uniqueId: `${data.v8context}-${data.isolate}`,
-          });
-        }
-      } else if (this.isRundownScript(event)) {
-        this.#scriptRundownEvents.push(event);
-        const data = event.args.data;
-        // Add script
-        if (!this.#scripts.find(
-                script => script.scriptId === String(data.scriptId) && script.isolate === String(data.isolate))) {
-          this.#scripts.push({
-            scriptId: String(data.scriptId) as Protocol.Runtime.ScriptId,
-            isolate: String(data.isolate),
-            buildId: '',
-            executionContextId: data.executionContextId,
-            startLine: data.startLine ?? 0,
-            startColumn: data.startColumn ?? 0,
-            endLine: data.endLine ?? 0,
-            endColumn: data.endColumn ?? 0,
-            hash: data.hash ?? '',
-            isModule: data.isModule,
-            url: data.url ?? '',
-            hasSourceURL: data.hasSourceUrl,
-            sourceURL: data.sourceUrl ?? '',
-            sourceMapURL: data.sourceMapUrl,
-            pid: event.pid,
-          });
-        }
-      } else if (this.isRundownScriptSource(event)) {
-        // Set up script to source text and length mapping
-        const data = event.args.data;
-        const scriptIsolateId = this.getScriptIsolateId(data.isolate, data.scriptId);
-        if ('splitIndex' in data && 'splitCount' in data) {
-          if (!this.#largeScriptToScriptSource.has(scriptIsolateId)) {
-            this.#largeScriptToScriptSource.set(scriptIsolateId, new Array(data.splitCount).fill('') as string[]);
-          }
-          const splittedSource = this.#largeScriptToScriptSource.get(scriptIsolateId);
-          if (splittedSource && data.sourceText) {
-            splittedSource[data.splitIndex as number] = data.sourceText;
-          }
-        } else {
-          if (data.sourceText) {
-            this.#scriptToScriptSource.set(scriptIsolateId, data.sourceText);
-          }
-          if (data.length) {
-            this.#scriptToSourceLength.set(scriptIsolateId, data.length);
-          }
-        }
-      }
-    }
-  }
-
-  data(): HydratingDataPerTarget[] {
-    // Put back execution context id
-    const v8ContextToExecutionContextId: Map<string, Protocol.Runtime.ExecutionContextId> =
-        new Map<string, Protocol.Runtime.ExecutionContextId>();
-    this.#scriptRundownEvents.forEach(scriptRundownEvent => {
-      const data = scriptRundownEvent.args.data;
-      const v8Context = this.#scriptToV8Context.get(this.getScriptIsolateId(data.isolate, data.scriptId));
-      if (v8Context) {
-        v8ContextToExecutionContextId.set(v8Context, data.executionContextId);
-      }
-    });
-    this.#executionContexts.forEach(executionContext => {
-      if (executionContext.v8Context) {
-        const id = v8ContextToExecutionContextId.get(executionContext.v8Context);
-        if (id) {
-          executionContext.id = id;
-        }
-      }
-    });
-
-    // Put back script source text and length
-    this.#scripts.forEach(script => {
-      const scriptIsolateId = this.getScriptIsolateId(script.isolate, script.scriptId);
-      if (this.#scriptToScriptSource.has(scriptIsolateId)) {
-        script.sourceText = this.#scriptToScriptSource.get(scriptIsolateId);
-        script.length = this.#scriptToSourceLength.get(scriptIsolateId);
-      } else if (this.#largeScriptToScriptSource.has(scriptIsolateId)) {
-        const splittedSources = this.#largeScriptToScriptSource.get(scriptIsolateId);
-        if (splittedSources) {
-          script.sourceText = splittedSources.join('');
-          script.length = script.sourceText.length;
-        }
-      }
-      // put in the aux data
-      const linkedExecutionContext = this.#executionContexts.find(
-          context => context.id === script.executionContextId && context.isolate === script.isolate);
-      if (linkedExecutionContext) {
-        script.executionContextAuxData = linkedExecutionContext.auxData;
-        // If a script successfully mapped to an execution context and aux data, link script to frame
-        if (script.executionContextAuxData?.frameId) {
-          this.#scriptToFrame.set(scriptIsolateId, script.executionContextAuxData?.frameId);
-        }
-      }
-    });
-
-    for (const script of this.#scripts) {
-      // Resolve the source map from the provided metadata.
-      // If no map is found for a given source map url, no source map is passed to the debugger model.
-      // Encoded as a data url so that the debugger model makes no network request.
-      // NOTE: consider passing directly as object and hacking `parsedScriptSource` in DebuggerModel.ts to handle
-      // this fake event. Would avoid a lot of wasteful (de)serialization. Maybe add SDK.Script.hydratedSourceMap.
-      this.resolveSourceMap(script);
-    }
-
-    return this.groupContextsAndScriptsUnderTarget(this.#targets, this.#executionContexts, this.#scripts);
-  }
-
-  private resolveSourceMap(script: RehydratingScript): void {
-    if (script.sourceMapURL?.startsWith('data:')) {
-      return;
-    }
-
-    const sourceMap = this.getSourceMapFromMetadata(script);
-    if (!sourceMap) {
-      return;
-    }
-
-    // Note: this encoding + re-parsing overhead cost ~10ms per 1MB of JSON on my
-    // Mac M1 Pro.
-    // See https://crrev.com/c/6490409/comments/f294c12a_69781e24
-    const payload = encodeURIComponent(JSON.stringify(sourceMap));
-    script.sourceMapURL = `data:application/json;charset=utf-8,${payload}`;
-  }
-
-  private getSourceMapFromMetadata(script: RehydratingScript): SourceMapV3|undefined {
-    const {hasSourceURL, sourceURL, url, sourceMapURL, isolate, scriptId} = script;
-
-    if (!sourceMapURL || !this.#trace.metadata.sourceMaps) {
-      return;
-    }
-
-    const frame =
-        this.#scriptToFrame.get(this.getScriptIsolateId(isolate, scriptId)) as string as Protocol.Target.TargetID;
-    if (!frame) {
-      return;
-    }
-
-    const target = this.#targets.find(t => t.targetId === frame);
-    if (!target) {
-      return;
-    }
-
-    let resolvedSourceUrl = url;
-    if (hasSourceURL && sourceURL) {
-      const targetUrl = target.url as Platform.DevToolsPath.UrlString;
-      resolvedSourceUrl = Common.ParsedURL.ParsedURL.completeURL(targetUrl, sourceURL) ?? sourceURL;
-    }
-
-    // Resolve the source map url. The value given by v8 may be relative, so resolve it here.
-    // This process should match the one in `SourceMapManager.attachSourceMap`.
-    const resolvedSourceMapUrl =
-        Common.ParsedURL.ParsedURL.completeURL(resolvedSourceUrl as Platform.DevToolsPath.UrlString, sourceMapURL);
-    if (!resolvedSourceMapUrl) {
-      return;
-    }
-
-    const {sourceMap} = this.#trace.metadata.sourceMaps.find(m => m.sourceMapUrl === resolvedSourceMapUrl) ?? {};
-    return sourceMap;
-  }
-
-  private getScriptIsolateId(isolate: number|string, scriptId: Protocol.Runtime.ScriptId|number): string {
-    return `${scriptId}@${isolate}`;
-  }
-
-  private getExecutionContextIsolateId(isolate: number|string, executionContextId: Protocol.Runtime.ExecutionContextId):
-      string {
-    return `${executionContextId}@${isolate}`;
-  }
-
-  private isTraceEvent(event: unknown): event is EventBase {
-    return 'cat' in (event as EventBase) && 'pid' in (event as EventBase) && 'args' in (event as EventBase) &&
-        'data' in (event as EventBase).args;
-  }
-
-  private isRundownScriptCompiled(event: unknown): event is RundownScriptCompiled {
-    return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.target-rundown';
-  }
-
-  private isRundownScript(event: unknown): event is RundownScript {
-    return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.v8-source-rundown';
-  }
-
-  private isRundownScriptSource(event: unknown): event is RundownScriptSource {
-    return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.v8-source-rundown-sources';
-  }
-
-  private isTracingStartedInBrowser(event: unknown): event is TracingStartedInBrowser {
-    return this.isTraceEvent(event) && event.cat === 'disabled-by-default-devtools.timeline' &&
-        event.name === 'TracingStartedInBrowser';
-  }
-
-  private isFunctionCallEvent(event: unknown): event is FunctionCall {
-    return this.isTraceEvent(event) && event.cat === 'devtools.timeline' && event.name === 'FunctionCall';
-  }
-
-  private groupContextsAndScriptsUnderTarget(
-      targets: RehydratingTarget[], executionContexts: RehydratingExecutionContext[],
-      scripts: RehydratingScript[]): HydratingDataPerTarget[] {
-    const data: HydratingDataPerTarget[] = [];
-    const targetIds = new Set<Protocol.Target.TargetID>();
-    const targetToExecutionContexts: Map<string, RehydratingExecutionContext[]> =
-        new Map<Protocol.Target.TargetID, RehydratingExecutionContext[]>();
-    // We want to keep track of how each execution context is linked to targets so we may use this
-    // information to link scripts with no target to a target
-    const executionContextIsolateToTarget: Map<string, Protocol.Target.TargetID> =
-        new Map<string, Protocol.Target.TargetID>();
-    const targetToScripts: Map<Protocol.Target.TargetID, RehydratingScript[]> =
-        new Map<Protocol.Target.TargetID, RehydratingScript[]>();
-    const orphanScripts: RehydratingScript[] = [];
-
-    // Initialize all the mapping needed
-    for (const target of targets) {
-      targetIds.add(target.targetId);
-      targetToExecutionContexts.set(target.targetId, []);
-      targetToScripts.set(target.targetId, []);
-    }
-
-    // Put all of the known execution contexts under respective targets
-    for (const executionContext of executionContexts) {
-      const frameId = executionContext.auxData?.frameId as string as Protocol.Target.TargetID;
-      if (frameId && targetIds.has(frameId)) {
-        targetToExecutionContexts.get(frameId)?.push(executionContext);
-        executionContextIsolateToTarget.set(
-            this.getExecutionContextIsolateId(executionContext.isolate, executionContext.id), frameId);
-      } else {
-        console.error('Execution context can\'t be linked to a target', executionContext);
-      }
-    }
-
-    // Put all of the scripts under respective targets with collected information
-    for (const script of scripts) {
-      const scriptExecutionContextIsolateId =
-          this.getExecutionContextIsolateId(script.isolate, script.executionContextId);
-      const scriptFrameId = script.executionContextAuxData?.frameId as string as Protocol.Target.TargetID;
-      if (script.executionContextAuxData?.frameId && targetIds.has(scriptFrameId)) {
-        targetToScripts.get(scriptFrameId)?.push(script);
-        executionContextIsolateToTarget.set(scriptExecutionContextIsolateId, scriptFrameId);
-      } else if (this.#scriptToFrame.has(this.getScriptIsolateId(script.isolate, script.scriptId))) {
-        const targetId = this.#scriptToFrame.get(this.getScriptIsolateId(script.isolate, script.scriptId)) as string as
-            Protocol.Target.TargetID;
-        if (targetId) {
-          targetToScripts.get(targetId)?.push(script);
-          executionContextIsolateToTarget.set(scriptExecutionContextIsolateId, targetId);
-        }
-      } else {
-        // These scripts are not linked to any target
-        orphanScripts.push(script);
-      }
-    }
-
-    // If a script is not linked to a target, use executionContext@isolate to link to a target
-    // Using PID is the last resort
-    for (const orphanScript of orphanScripts) {
-      const orphanScriptExecutionContextIsolateId =
-          this.getExecutionContextIsolateId(orphanScript.isolate, orphanScript.executionContextId);
-      const frameId = executionContextIsolateToTarget.get(orphanScriptExecutionContextIsolateId);
-
-      if (frameId) {
-        // Found a link via execution context, use it.
-        targetToScripts.get(frameId)?.push(orphanScript);
-      } else if (orphanScript.pid) {
-        const target = targets.find(target => target.pid === orphanScript.pid);
-        if (target) {
-          targetToScripts.get(target.targetId)?.push(orphanScript);
-        }
-      } else {
-        console.error('Script can\'t be linked to any target', orphanScript);
-      }
-    }
-
-    // Now all the scripts are linked to a target, we want to make sure all the scripts are pointing to a valid
-    // execution context. If not, we will create an artificial execution context for the script
-    for (const target of targets) {
-      const targetId = target.targetId;
-      const executionContexts = targetToExecutionContexts.get(targetId) || [];
-      const scripts = targetToScripts.get(targetId) || [];
-      for (const script of scripts) {
-        if (!executionContexts.find(context => context.id === script.executionContextId)) {
-          const artificialContext: RehydratingExecutionContext = {
-            id: script.executionContextId,
-            origin: '',
-            v8Context: '',
-            name: '',
-            auxData: {
-              frameId: targetId as string as Protocol.Page.FrameId,
-              isDefault: false,
-              type: 'type',
-            },
-            isolate: script.isolate,
-            uniqueId: `${targetId}-${script.isolate}`,
-          };
-          executionContexts.push(artificialContext);
-        }
-      }
-
-      // Finally, we put all the information into the data structure we want to return as.
-      data.push({target, executionContexts, scripts});
-    }
-
-    return data;
-  }
-}

package/lib/front_end/core/sdk/EventBreakpointsModel.ts

@@ -1,183 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-
-import {CategorizedBreakpoint, Category} from './CategorizedBreakpoint.js';
-import type {EventListenerPausedDetailsAuxData} from './DebuggerModel.js';
-import {SDKModel} from './SDKModel.js';
-import {Capability, type Target} from './Target.js';
-import {type SDKModelObserver, TargetManager} from './TargetManager.js';
-
-export const enum InstrumentationNames {
-  BEFORE_BIDDER_WORKLET_BIDDING_START = 'beforeBidderWorkletBiddingStart',
-  BEFORE_BIDDER_WORKLET_REPORTING_START = 'beforeBidderWorkletReportingStart',
-  BEFORE_SELLER_WORKLET_SCORING_START = 'beforeSellerWorkletScoringStart',
-  BEFORE_SELLER_WORKLET_REPORTING_START = 'beforeSellerWorkletReportingStart',
-  SET_TIMEOUT = 'setTimeout',
-  CLEAR_TIMEOUT = 'clearTimeout',
-  SET_TIMEOUT_CALLBACK = 'setTimeout.callback',
-  SET_INTERVAL = 'setInterval',
-  CLEAR_INTERVAL = 'clearInterval',
-  SET_INTERVAL_CALLBACK = 'setInterval.callback',
-  SCRIPT_FIRST_STATEMENT = 'scriptFirstStatement',
-  SCRIPT_BLOCKED_BY_CSP = 'scriptBlockedByCSP',
-  SHARED_STORAGE_WORKLET_SCRIPT_FIRST_STATEMENT = 'sharedStorageWorkletScriptFirstStatement',
-  REQUEST_ANIMATION_FRAME = 'requestAnimationFrame',
-  CANCEL_ANIMATION_FRAME = 'cancelAnimationFrame',
-  REQUEST_ANIMATION_FRAME_CALLBACK = 'requestAnimationFrame.callback',
-  WEBGL_ERROR_FIRED = 'webglErrorFired',
-  WEBGL_WARNING_FIRED = 'webglWarningFired',
-  ELEMENT_SET_INNER_HTML = 'Element.setInnerHTML',
-  CANVAS_CONTEXT_CREATED = 'canvasContextCreated',
-  GEOLOCATION_GET_CURRENT_POSITION = 'Geolocation.getCurrentPosition',
-  GEOLOCATION_WATCH_POSITION = 'Geolocation.watchPosition',
-  NOTIFICATION_REQUEST_PERMISSION = 'Notification.requestPermission',
-  DOM_WINDOW_CLOSE = 'DOMWindow.close',
-  DOCUMENT_WRITE = 'Document.write',
-  AUDIO_CONTEXT_CREATED = 'audioContextCreated',
-  AUDIO_CONTEXT_CLOSED = 'audioContextClosed',
-  AUDIO_CONTEXT_RESUMED = 'audioContextResumed',
-  AUDIO_CONTEXT_SUSPENDED = 'audioContextSuspended',
-}
-
-export class EventBreakpointsModel extends SDKModel<void> {
-  readonly agent: ProtocolProxyApi.EventBreakpointsApi;
-
-  constructor(target: Target) {
-    super(target);
-    this.agent = target.eventBreakpointsAgent();
-  }
-}
-
-/**
- * This implementation (as opposed to similar class in DOMDebuggerModel) is for
- * instrumentation breakpoints in targets that run JS but do not have a DOM.
- **/
-class EventListenerBreakpoint extends CategorizedBreakpoint {
-  override setEnabled(enabled: boolean): void {
-    if (this.enabled() === enabled) {
-      return;
-    }
-    super.setEnabled(enabled);
-    for (const model of TargetManager.instance().models(EventBreakpointsModel)) {
-      this.updateOnModel(model);
-    }
-  }
-
-  updateOnModel(model: EventBreakpointsModel): void {
-    if (this.enabled()) {
-      void model.agent.invoke_setInstrumentationBreakpoint({eventName: this.name});
-    } else {
-      void model.agent.invoke_removeInstrumentationBreakpoint({eventName: this.name});
-    }
-  }
-
-  static readonly instrumentationPrefix = 'instrumentation:';
-}
-
-let eventBreakpointManagerInstance: EventBreakpointsManager;
-
-export class EventBreakpointsManager implements SDKModelObserver<EventBreakpointsModel> {
-  readonly #eventListenerBreakpoints: EventListenerBreakpoint[] = [];
-
-  constructor() {
-    this.createInstrumentationBreakpoints(Category.AUCTION_WORKLET, [
-      InstrumentationNames.BEFORE_BIDDER_WORKLET_BIDDING_START,
-      InstrumentationNames.BEFORE_BIDDER_WORKLET_REPORTING_START,
-      InstrumentationNames.BEFORE_SELLER_WORKLET_SCORING_START,
-      InstrumentationNames.BEFORE_SELLER_WORKLET_REPORTING_START,
-    ]);
-    this.createInstrumentationBreakpoints(Category.ANIMATION, [
-      InstrumentationNames.REQUEST_ANIMATION_FRAME,
-      InstrumentationNames.CANCEL_ANIMATION_FRAME,
-      InstrumentationNames.REQUEST_ANIMATION_FRAME_CALLBACK,
-    ]);
-    this.createInstrumentationBreakpoints(Category.CANVAS, [
-      InstrumentationNames.CANVAS_CONTEXT_CREATED,
-      InstrumentationNames.WEBGL_ERROR_FIRED,
-      InstrumentationNames.WEBGL_WARNING_FIRED,
-    ]);
-    this.createInstrumentationBreakpoints(Category.GEOLOCATION, [
-      InstrumentationNames.GEOLOCATION_GET_CURRENT_POSITION,
-      InstrumentationNames.GEOLOCATION_WATCH_POSITION,
-    ]);
-    this.createInstrumentationBreakpoints(Category.NOTIFICATION, [
-      InstrumentationNames.NOTIFICATION_REQUEST_PERMISSION,
-    ]);
-    this.createInstrumentationBreakpoints(Category.PARSE, [
-      InstrumentationNames.ELEMENT_SET_INNER_HTML,
-      InstrumentationNames.DOCUMENT_WRITE,
-    ]);
-    this.createInstrumentationBreakpoints(Category.SCRIPT, [
-      InstrumentationNames.SCRIPT_FIRST_STATEMENT,
-      InstrumentationNames.SCRIPT_BLOCKED_BY_CSP,
-    ]);
-    this.createInstrumentationBreakpoints(Category.SHARED_STORAGE_WORKLET, [
-      InstrumentationNames.SHARED_STORAGE_WORKLET_SCRIPT_FIRST_STATEMENT,
-    ]);
-    this.createInstrumentationBreakpoints(Category.TIMER, [
-      InstrumentationNames.SET_TIMEOUT,
-      InstrumentationNames.CLEAR_TIMEOUT,
-      InstrumentationNames.SET_TIMEOUT_CALLBACK,
-      InstrumentationNames.SET_INTERVAL,
-      InstrumentationNames.CLEAR_INTERVAL,
-      InstrumentationNames.SET_INTERVAL_CALLBACK,
-    ]);
-    this.createInstrumentationBreakpoints(Category.WINDOW, [
-      InstrumentationNames.DOM_WINDOW_CLOSE,
-    ]);
-    this.createInstrumentationBreakpoints(Category.WEB_AUDIO, [
-      InstrumentationNames.AUDIO_CONTEXT_CREATED,
-      InstrumentationNames.AUDIO_CONTEXT_CLOSED,
-      InstrumentationNames.AUDIO_CONTEXT_RESUMED,
-      InstrumentationNames.AUDIO_CONTEXT_SUSPENDED,
-    ]);
-
-    TargetManager.instance().observeModels(EventBreakpointsModel, this);
-  }
-
-  static instance(opts: {
-    forceNew: boolean|null,
-  } = {forceNew: null}): EventBreakpointsManager {
-    const {forceNew} = opts;
-    if (!eventBreakpointManagerInstance || forceNew) {
-      eventBreakpointManagerInstance = new EventBreakpointsManager();
-    }
-
-    return eventBreakpointManagerInstance;
-  }
-
-  private createInstrumentationBreakpoints(category: Category, instrumentationNames: InstrumentationNames[]): void {
-    for (const instrumentationName of instrumentationNames) {
-      this.#eventListenerBreakpoints.push(new EventListenerBreakpoint(category, instrumentationName));
-    }
-  }
-
-  eventListenerBreakpoints(): EventListenerBreakpoint[] {
-    return this.#eventListenerBreakpoints.slice();
-  }
-
-  resolveEventListenerBreakpoint({eventName}: EventListenerPausedDetailsAuxData): EventListenerBreakpoint|null {
-    if (!eventName.startsWith(EventListenerBreakpoint.instrumentationPrefix)) {
-      return null;
-    }
-
-    const instrumentationName = eventName.substring(EventListenerBreakpoint.instrumentationPrefix.length);
-    return this.#eventListenerBreakpoints.find(b => b.name === instrumentationName) || null;
-  }
-
-  modelAdded(eventBreakpointModel: EventBreakpointsModel): void {
-    for (const breakpoint of this.#eventListenerBreakpoints) {
-      if (breakpoint.enabled()) {
-        breakpoint.updateOnModel(eventBreakpointModel);
-      }
-    }
-  }
-
-  modelRemoved(_eventBreakpointModel: EventBreakpointsModel): void {
-  }
-}
-
-SDKModel.register(EventBreakpointsModel, {capabilities: Capability.EVENT_BREAKPOINTS, autostart: false});