chrome-devtools-frontend 1.0.1020771 → 1.0.1022059

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -14,6 +14,7 @@ import {ContentProviderBasedProject} from './ContentProviderBasedProject.js';
 
 import type {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
 import {NetworkProject} from './NetworkProject.js';
+import {assertNotNullOrUndefined} from '../../core/platform/platform.js';
 
 const UIStrings = {
   /**
@@ -168,6 +169,10 @@ export class ValueNode extends SDK.RemoteObject.RemoteObjectImpl {
     this.inspectableAddress = inspectableAddress;
     this.callFrame = callFrame;
   }
+
+  get sourceType(): SourceType {
+    throw new Error('Not Implemented');
+  }
 }
 
 // Debugger language #plugins present source-language values as trees with mixed dynamic and static structural
@@ -214,7 +219,7 @@ async function getValueTreeForExpression(
   try {
     typeInfo = await plugin.getTypeInfo(expression, location);
   } catch (e) {
-    FormattingError.throwLocal(callFrame, e.message);
+    throw FormattingError.makeLocal(callFrame, e.message);
   }
   // If there's no type information we cannot represent this expression.
   if (!typeInfo) {
@@ -450,7 +455,7 @@ class FormattingError extends Error {
     this.exceptionDetails = exceptionDetails;
   }
 
-  static throwLocal(callFrame: SDK.DebuggerModel.CallFrame, message: string): void {
+  static makeLocal(callFrame: SDK.DebuggerModel.CallFrame, message: string): FormattingError {
     const exception: Protocol.Runtime.RemoteObject = {
       type: Protocol.Runtime.RemoteObjectType.Object,
       subtype: Protocol.Runtime.RemoteObjectSubtype.Error,
@@ -459,7 +464,7 @@ class FormattingError extends Error {
     const exceptionDetails: Protocol.Runtime
         .ExceptionDetails = {text: 'Uncaught', exceptionId: -1, columnNumber: 0, lineNumber: 0, exception};
     const errorObject = callFrame.debuggerModel.runtimeModel().createRemoteObject(exception);
-    throw new FormattingError(errorObject, exceptionDetails);
+    return new FormattingError(errorObject, exceptionDetails);
   }
 }
 
@@ -500,6 +505,10 @@ class StaticallyTypedValueNode extends ValueNode {
     return this.#variableType;
   }
 
+  get sourceType(): SourceType {
+    return this.#sourceType;
+  }
+
   private async expandMember(sourceType: SourceType, fieldInfo: Chrome.DevTools.FieldInfo):
       Promise<SDK.RemoteObject.RemoteObject> {
     const fieldChain = this.#fieldChain.concat(fieldInfo);
@@ -615,12 +624,14 @@ class SourceScopeRemoteObject extends SDK.RemoteObject.RemoteObjectImpl {
   variables: Chrome.DevTools.Variable[];
   #callFrame: SDK.DebuggerModel.CallFrame;
   #plugin: DebuggerLanguagePlugin;
+  stopId: StopId;
 
-  constructor(callFrame: SDK.DebuggerModel.CallFrame, plugin: DebuggerLanguagePlugin) {
+  constructor(callFrame: SDK.DebuggerModel.CallFrame, stopId: StopId, plugin: DebuggerLanguagePlugin) {
     super(callFrame.debuggerModel.runtimeModel(), undefined, 'object', undefined, null);
     this.variables = [];
     this.#callFrame = callFrame;
     this.#plugin = plugin;
+    this.stopId = stopId;
   }
 
   async doGetProperties(ownProperties: boolean, accessorPropertiesOnly: boolean, _generatePreview: boolean):
@@ -691,13 +702,13 @@ export class SourceScope implements SDK.DebuggerModel.ScopeChainEntry {
   readonly #startLocationInternal: SDK.DebuggerModel.Location|null;
   readonly #endLocationInternal: SDK.DebuggerModel.Location|null;
   constructor(
-      callFrame: SDK.DebuggerModel.CallFrame, type: string, typeName: string, icon: string|undefined,
+      callFrame: SDK.DebuggerModel.CallFrame, stopId: StopId, type: string, typeName: string, icon: string|undefined,
       plugin: DebuggerLanguagePlugin) {
     this.#callFrameInternal = callFrame;
     this.#typeInternal = type;
     this.#typeNameInternal = typeName;
     this.#iconInternal = icon;
-    this.#objectInternal = new SourceScopeRemoteObject(callFrame, plugin);
+    this.#objectInternal = new SourceScopeRemoteObject(callFrame, stopId, plugin);
     this.#startLocationInternal = null;
     this.#endLocationInternal = null;
   }
@@ -756,6 +767,115 @@ export class SourceScope implements SDK.DebuggerModel.ScopeChainEntry {
   }
 }
 
+export class ExtensionRemoteObject extends SDK.RemoteObject.RemoteObject {
+  private readonly extensionObject: Chrome.DevTools.RemoteObject;
+  private readonly plugin: DebuggerLanguagePlugin;
+  readonly callFrame: SDK.DebuggerModel.CallFrame;
+  constructor(
+      callFrame: SDK.DebuggerModel.CallFrame, extensionObject: Chrome.DevTools.RemoteObject,
+      plugin: DebuggerLanguagePlugin) {
+    super();
+    this.extensionObject = extensionObject;
+    this.plugin = plugin;
+    this.callFrame = callFrame;
+  }
+
+  get linearMemoryAddress(): number|undefined {
+    return this.extensionObject.linearMemoryAddress;
+  }
+
+  get objectId(): Protocol.Runtime.RemoteObjectId|undefined {
+    return this.extensionObject.objectId as Protocol.Runtime.RemoteObjectId;
+  }
+
+  get type(): string {
+    if (this.extensionObject.type === 'array' || this.extensionObject.type === 'null') {
+      return 'object';
+    }
+    return this.extensionObject.type;
+  }
+
+  get subtype(): string|undefined {
+    if (this.extensionObject.type === 'array' || this.extensionObject.type === 'null') {
+      return this.extensionObject.type;
+    }
+    return undefined;
+  }
+
+  get value(): unknown {
+    return this.extensionObject.value;
+  }
+
+  unserializableValue(): string|undefined {
+    return undefined;
+  }
+
+  get description(): string|undefined {
+    return this.extensionObject.description;
+  }
+
+  set description(description: string|undefined) {
+  }
+
+  get hasChildren(): boolean {
+    return this.extensionObject.hasChildren;
+  }
+
+  get preview(): Protocol.Runtime.ObjectPreview|undefined {
+    return undefined;
+  }
+
+  get className(): string|null {
+    return this.extensionObject.className ?? null;
+  }
+
+  arrayLength(): number {
+    return 0;
+  }
+
+  arrayBufferByteLength(): number {
+    return 0;
+  }
+
+  getOwnProperties(_generatePreview: boolean, _nonIndexedPropertiesOnly?: boolean):
+      Promise<SDK.RemoteObject.GetPropertiesResult> {
+    return this.getAllProperties(false, _generatePreview, _nonIndexedPropertiesOnly);
+  }
+
+  async getAllProperties(
+      _accessorPropertiesOnly: boolean, _generatePreview: boolean,
+      _nonIndexedPropertiesOnly?: boolean): Promise<SDK.RemoteObject.GetPropertiesResult> {
+    const {objectId} = this.extensionObject;
+    if (objectId) {
+      assertNotNullOrUndefined(this.plugin.getProperties);
+      const extensionObjectProperties = await this.plugin.getProperties(objectId);
+      const properties = extensionObjectProperties.map(
+          p => new SDK.RemoteObject.RemoteObjectProperty(
+              p.name, new ExtensionRemoteObject(this.callFrame, p.value, this.plugin)));
+      return {properties, internalProperties: null};
+    }
+
+    return {properties: null, internalProperties: null};
+  }
+
+  release(): void {
+    const {objectId} = this.extensionObject;
+    if (objectId) {
+      assertNotNullOrUndefined(this.plugin.releaseObject);
+      void this.plugin.releaseObject(objectId);
+    }
+  }
+
+  debuggerModel(): SDK.DebuggerModel.DebuggerModel {
+    return this.callFrame.debuggerModel;
+  }
+
+  runtimeModel(): SDK.RuntimeModel.RuntimeModel {
+    return this.callFrame.debuggerModel.runtimeModel();
+  }
+}
+
+export type StopId = bigint;
 export class DebuggerLanguagePluginManager implements
     SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
   readonly #workspace: Workspace.Workspace.WorkspaceImpl;
@@ -768,6 +888,9 @@ export class DebuggerLanguagePluginManager implements
     scripts: Array<SDK.Script.Script>,
     addRawModulePromise: Promise<Array<Platform.DevToolsPath.UrlString>|{missingSymbolFiles: string[]}>,
   }>;
+  private readonly callFrameByStopId: Map<StopId, SDK.DebuggerModel.CallFrame> = new Map();
+  private readonly stopIdByCallFrame: Map<SDK.DebuggerModel.CallFrame, StopId> = new Map();
+  private nextStopId: StopId = 0n;
 
   constructor(
       targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl,
@@ -810,10 +933,27 @@ export class DebuggerLanguagePluginManager implements
         const {exception: object, exceptionDetails} = error;
         return {object, exceptionDetails};
       }
-      return {error: error.message};
+      const {exception: object, exceptionDetails} = FormattingError.makeLocal(callFrame, error.message);
+      return {object, exceptionDetails};
     }
   }
 
+  stopIdForCallFrame(callFrame: SDK.DebuggerModel.CallFrame): StopId {
+    let stopId = this.stopIdByCallFrame.get(callFrame);
+    if (stopId !== undefined) {
+      return stopId;
+    }
+
+    stopId = this.nextStopId++;
+    this.stopIdByCallFrame.set(callFrame, stopId);
+    this.callFrameByStopId.set(stopId, callFrame);
+    return stopId;
+  }
+
+  callFrameForStopId(stopId: StopId): SDK.DebuggerModel.CallFrame|undefined {
+    return this.callFrameByStopId.get(stopId);
+  }
+
   private expandCallFrames(callFrames: SDK.DebuggerModel.CallFrame[]): Promise<SDK.DebuggerModel.CallFrame[]> {
     return Promise
         .all(callFrames.map(async callFrame => {
@@ -842,6 +982,7 @@ export class DebuggerLanguagePluginManager implements
     this.#debuggerModelToData.set(debuggerModel, new ModelData(debuggerModel, this.#workspace));
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this);
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this);
+    debuggerModel.addEventListener(SDK.DebuggerModel.Events.DebuggerResumed, this.debuggerResumed, this);
     debuggerModel.setEvaluateOnCallFrameCallback(this.evaluateOnCallFrame.bind(this));
     debuggerModel.setExpandCallFramesCallback(this.expandCallFrames.bind(this));
   }
@@ -849,6 +990,7 @@ export class DebuggerLanguagePluginManager implements
   modelRemoved(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
     debuggerModel.removeEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this);
     debuggerModel.removeEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this);
+    debuggerModel.removeEventListener(SDK.DebuggerModel.Events.DebuggerResumed, this.debuggerResumed, this);
     debuggerModel.setEvaluateOnCallFrameCallback(null);
     debuggerModel.setExpandCallFramesCallback(null);
     const modelData = this.#debuggerModelToData.get(debuggerModel);
@@ -1136,6 +1278,17 @@ export class DebuggerLanguagePluginManager implements
     }
   }
 
+  private debuggerResumed(event: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.DebuggerModel>): void {
+    const resumedFrames =
+        Array.from(this.callFrameByStopId.values()).filter(callFrame => callFrame.debuggerModel === event.data);
+    for (const callFrame of resumedFrames) {
+      const stopId = this.stopIdByCallFrame.get(callFrame);
+      assertNotNullOrUndefined(stopId);
+      this.stopIdByCallFrame.delete(callFrame);
+      this.callFrameByStopId.delete(stopId);
+    }
+  }
+
   getSourcesForScript(script: SDK.Script.Script):
       Promise<Array<Platform.DevToolsPath.UrlString>|{missingSymbolFiles: string[]}|undefined> {
     const rawModuleId = rawModuleIdForScript(script);
@@ -1159,6 +1312,8 @@ export class DebuggerLanguagePluginManager implements
       inlineFrameIndex: callFrame.inlineFrameIndex,
     };
 
+    const stopId = this.stopIdForCallFrame(callFrame);
+
     try {
       const sourceMapping = await plugin.rawLocationToSourceLocation(location);
       if (sourceMapping.length === 0) {
@@ -1170,7 +1325,7 @@ export class DebuggerLanguagePluginManager implements
         let scope = scopes.get(variable.scope);
         if (!scope) {
           const {type, typeName, icon} = await plugin.getScopeInfo(variable.scope);
-          scope = new SourceScope(callFrame, type, typeName, icon, plugin);
+          scope = new SourceScope(callFrame, stopId, type, typeName, icon, plugin);
           scopes.set(variable.scope, scope);
         }
         scope.object().variables.push(variable);
@@ -1371,114 +1526,7 @@ class ModelData {
   }
 }
 
-export class DebuggerLanguagePlugin implements Chrome.DevTools.LanguageExtensionPlugin {
+export interface DebuggerLanguagePlugin extends Chrome.DevTools.LanguageExtensionPlugin {
   name: string;
-  constructor(name: string) {
-    this.name = name;
-  }
-
-  handleScript(_script: SDK.Script.Script): boolean {
-    throw new Error('Not implemented yet');
-  }
-
-  dispose(): void {
-  }
-
-  /** Notify the #plugin about a new script
-    */
-  async addRawModule(_rawModuleId: string, _symbolsURL: string, _rawModule: Chrome.DevTools.RawModule):
-      Promise<string[]|{missingSymbolFiles: string[]}> {
-    throw new Error('Not implemented yet');
-  }
-
-  /** Find #locations in raw modules from a #location in a source file
-    */
-  async sourceLocationToRawLocation(_sourceLocation: Chrome.DevTools.SourceLocation):
-      Promise<Chrome.DevTools.RawLocationRange[]> {
-    throw new Error('Not implemented yet');
-  }
-
-  /** Find #locations in source files from a #location in a raw module
-    */
-  async rawLocationToSourceLocation(_rawLocation: Chrome.DevTools.RawLocation):
-      Promise<Chrome.DevTools.SourceLocation[]> {
-    throw new Error('Not implemented yet');
-  }
-
-  /** Return detailed information about a scope
-     */
-  async getScopeInfo(_type: string): Promise<Chrome.DevTools.ScopeInfo> {
-    throw new Error('Not implemented yet');
-  }
-
-  /** List all variables in lexical scope at a given #location in a raw module
-    */
-  async listVariablesInScope(_rawLocation: Chrome.DevTools.RawLocation): Promise<Chrome.DevTools.Variable[]> {
-    throw new Error('Not implemented yet');
-  }
-
-  /**
-   * Notifies the #plugin that a script is removed.
-   */
-  removeRawModule(_rawModuleId: string): Promise<void> {
-    throw new Error('Not implemented yet');
-  }
-
-  getTypeInfo(_expression: string, _context: Chrome.DevTools.RawLocation): Promise<{
-    typeInfos: Array<Chrome.DevTools.TypeInfo>,
-    base: Chrome.DevTools.EvalBase,
-  }|null> {
-    throw new Error('Not implemented yet');
-  }
-
-  getFormatter(
-      _expressionOrField: string|{
-        base: Chrome.DevTools.EvalBase,
-        field: Array<Chrome.DevTools.FieldInfo>,
-      },
-      _context: Chrome.DevTools.RawLocation): Promise<{
-    js: string,
-  }|null> {
-    throw new Error('Not implemented yet');
-  }
-
-  getInspectableAddress(_field: {
-    base: Chrome.DevTools.EvalBase,
-    field: Array<Chrome.DevTools.FieldInfo>,
-  }): Promise<{
-    js: string,
-  }> {
-    throw new Error('Not implemented yet');
-  }
-
-  /**
-   * Find #locations in source files from a #location in a raw module
-   */
-  async getFunctionInfo(_rawLocation: Chrome.DevTools.RawLocation):
-      Promise<{frames: Array<Chrome.DevTools.FunctionInfo>}|{missingSymbolFiles: string[]}> {
-    throw new Error('Not implemented yet');
-  }
-
-  /**
-   * Find #locations in raw modules corresponding to the inline function
-   * that rawLocation is in. Used for stepping out of an inline function.
-   */
-  async getInlinedFunctionRanges(_rawLocation: Chrome.DevTools.RawLocation):
-      Promise<Chrome.DevTools.RawLocationRange[]> {
-    throw new Error('Not implemented yet');
-  }
-
-  /**
-   * Find #locations in raw modules corresponding to inline functions
-   * called by the function or inline frame that rawLocation is in.
-   * Used for stepping over inline functions.
-   */
-  async getInlinedCalleesRanges(_rawLocation: Chrome.DevTools.RawLocation):
-      Promise<Chrome.DevTools.RawLocationRange[]> {
-    throw new Error('Not implemented yet');
-  }
-
-  async getMappedLines(_rawModuleId: string, _sourceFileURL: string): Promise<number[]|undefined> {
-    throw new Error('Not implemented yet');
-  }
+  handleScript(script: SDK.Script.Script): boolean;
 }

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -30,10 +30,10 @@
 
 import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
-import type * as Platform from '../../core/platform/platform.js';
+import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
-import * as Workspace from '../workspace/workspace.js';
 import * as Protocol from '../../generated/protocol.js';
+import * as Workspace from '../workspace/workspace.js';
 
 import type {Breakpoint} from './BreakpointManager.js';
 import {BreakpointManager} from './BreakpointManager.js';
@@ -65,7 +65,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
   readonly debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
   readonly #uiSourceCodeToScriptFile: Map<Workspace.UISourceCode.UISourceCode, ResourceScriptFile>;
   readonly #projects: Map<string, ContentProviderBasedProject>;
-  #acceptedScripts: Set<SDK.Script.Script>;
+  readonly #scriptToUISourceCode: Map<SDK.Script.Script, Workspace.UISourceCode.UISourceCode>;
   readonly #eventListeners: Common.EventTarget.EventDescriptor[];
 
   constructor(
@@ -78,21 +78,30 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
 
     this.#projects = new Map();
 
-    this.#acceptedScripts = new Set();
+    this.#scriptToUISourceCode = new Map();
     const runtimeModel = debuggerModel.runtimeModel();
     this.#eventListeners = [
       this.debuggerModel.addEventListener(
-          SDK.DebuggerModel.Events.ParsedScriptSource,
-          event => {
-            void this.parsedScriptSource(event);
-          },
-          this),
+          SDK.DebuggerModel.Events.ParsedScriptSource, event => this.addScript(event.data), this),
       this.debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this),
       runtimeModel.addEventListener(
           SDK.RuntimeModel.Events.ExecutionContextDestroyed, this.executionContextDestroyed, this),
+      runtimeModel.target().targetManager().addEventListener(
+          SDK.TargetManager.Events.InspectedURLChanged, this.inspectedURLChanged, this),
     ];
   }
 
+  static resolveRelativeSourceURL(script: SDK.Script.Script, url: Platform.DevToolsPath.UrlString):
+      Platform.DevToolsPath.UrlString {
+    let target: SDK.Target.Target|null = script.debuggerModel.target();
+    while (target && target.type() !== SDK.Target.Type.Frame) {
+      target = target.parentTarget();
+    }
+    const baseURL = target?.inspectedURL() ?? Platform.DevToolsPath.EmptyUrlString;
+    url = Common.ParsedURL.ParsedURL.completeURL(baseURL, url) ?? url;
+    return url;
+  }
+
   private project(script: SDK.Script.Script): ContentProviderBasedProject {
     const prefix = script.isContentScript() ? 'js:extensions:' : 'js::';
     const projectId = prefix + this.debuggerModel.target().id() + ':' + script.frameId;
@@ -113,8 +122,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     if (!script) {
       return null;
     }
-    const project = this.project(script);
-    const uiSourceCode = project.uiSourceCodeForURL(script.sourceURL);
+    const uiSourceCode = this.#scriptToUISourceCode.get(script);
     if (!uiSourceCode) {
       return null;
     }
@@ -147,41 +155,63 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     return [this.debuggerModel.createRawLocation(script, lineNumber, columnNumber)];
   }
 
-  private acceptsScript(script: SDK.Script.Script): boolean {
-    if (!script.sourceURL || script.isLiveEdit() || (script.isInlineScript() && !script.hasSourceURL)) {
-      return false;
-    }
-    // Filter out embedder injected content scripts.
-    if (script.isContentScript() && !script.hasSourceURL) {
-      const parsedURL = new Common.ParsedURL.ParsedURL(script.sourceURL);
-      if (!parsedURL.isValid) {
-        return false;
+  private inspectedURLChanged(event: Common.EventTarget.EventTargetEvent<SDK.Target.Target>): void {
+    for (let target: SDK.Target.Target|null = this.debuggerModel.target(); target !== event.data;
+         target = target.parentTarget()) {
+      if (target === null) {
+        return;
       }
     }
-    return true;
+
+    // Just remove and readd all scripts to ensure their URLs are reflected correctly.
+    for (const script of Array.from(this.#scriptToUISourceCode.keys())) {
+      this.removeScript(script);
+      this.addScript(script);
+    }
   }
 
-  private async parsedScriptSource(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): Promise<void> {
-    const script = event.data;
-    if (!this.acceptsScript(script)) {
+  private addScript(script: SDK.Script.Script): void {
+    // Ignore live edit scripts here.
+    if (script.isLiveEdit()) {
       return;
     }
-    this.#acceptedScripts.add(script);
-    const originalContentProvider = script.originalContentProvider();
 
-    const url = script.sourceURL;
-    const project = this.project(script);
+    let url = script.sourceURL;
+    if (!url) {
+      return;
+    }
+
+    if (script.hasSourceURL) {
+      // Try to resolve `//# sourceURL=` annotations relative to
+      // the base URL, according to the sourcemap specification.
+      url = ResourceScriptMapping.resolveRelativeSourceURL(script, url);
+    } else {
+      // Ignore inline <script>s without `//# sourceURL` annotation here.
+      if (script.isInlineScript()) {
+        return;
+      }
+
+      // Filter out embedder injected content scripts.
+      if (script.isContentScript()) {
+        const parsedURL = new Common.ParsedURL.ParsedURL(url);
+        if (!parsedURL.isValid) {
+          return;
+        }
+      }
+    }
 
     // Remove previous UISourceCode, if any
+    const project = this.project(script);
     const oldUISourceCode = project.uiSourceCodeForURL(url);
     if (oldUISourceCode) {
-      const scriptFile = this.#uiSourceCodeToScriptFile.get(oldUISourceCode);
-      if (scriptFile && scriptFile.script) {
-        await this.removeScript(scriptFile.script);
+      const oldScriptFile = this.#uiSourceCodeToScriptFile.get(oldUISourceCode);
+      if (oldScriptFile && oldScriptFile.script) {
+        this.removeScript(oldScriptFile.script);
       }
     }
 
     // Create UISourceCode.
+    const originalContentProvider = script.originalContentProvider();
     const uiSourceCode = project.createUISourceCode(url, originalContentProvider.contentType());
     NetworkProject.setInitialFrameAttribution(uiSourceCode, script.frameId);
     const metadata = metadataForURL(this.debuggerModel.target(), script.frameId, url);
@@ -189,61 +219,54 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     // Bind UISourceCode to scripts.
     const scriptFile = new ResourceScriptFile(this, uiSourceCode, [script]);
     this.#uiSourceCodeToScriptFile.set(uiSourceCode, scriptFile);
+    this.#scriptToUISourceCode.set(script, uiSourceCode);
 
     const mimeType = script.isWasm() ? 'application/wasm' : 'text/javascript';
     project.addUISourceCodeWithProvider(uiSourceCode, originalContentProvider, metadata, mimeType);
-    await this.debuggerWorkspaceBinding.updateLocations(script);
+    void this.debuggerWorkspaceBinding.updateLocations(script);
   }
 
   scriptFile(uiSourceCode: Workspace.UISourceCode.UISourceCode): ResourceScriptFile|null {
     return this.#uiSourceCodeToScriptFile.get(uiSourceCode) || null;
   }
 
-  private async removeScript(script: SDK.Script.Script): Promise<void> {
-    if (!this.#acceptedScripts.has(script)) {
+  private removeScript(script: SDK.Script.Script): void {
+    const uiSourceCode = this.#scriptToUISourceCode.get(script);
+    if (!uiSourceCode) {
       return;
     }
-    this.#acceptedScripts.delete(script);
-    const project = this.project(script);
-    const uiSourceCode = (project.uiSourceCodeForURL(script.sourceURL) as Workspace.UISourceCode.UISourceCode);
     const scriptFile = this.#uiSourceCodeToScriptFile.get(uiSourceCode);
     if (scriptFile) {
       scriptFile.dispose();
     }
     this.#uiSourceCodeToScriptFile.delete(uiSourceCode);
-    project.removeFile(script.sourceURL);
-    await this.debuggerWorkspaceBinding.updateLocations(script);
+    this.#scriptToUISourceCode.delete(script);
+    const project = uiSourceCode.project() as ContentProviderBasedProject;
+    project.removeFile(uiSourceCode.url());
+    void this.debuggerWorkspaceBinding.updateLocations(script);
   }
 
   private executionContextDestroyed(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext>):
       void {
     const executionContext = event.data;
-    const scripts = this.debuggerModel.scriptsForExecutionContext(executionContext);
-    for (const script of scripts) {
-      void this.removeScript(script);
+    for (const script of this.debuggerModel.scriptsForExecutionContext(executionContext)) {
+      this.removeScript(script);
     }
   }
 
   private globalObjectCleared(): void {
-    const scripts = Array.from(this.#acceptedScripts);
-    for (const script of scripts) {
-      void this.removeScript(script);
+    for (const script of this.#scriptToUISourceCode.keys()) {
+      this.removeScript(script);
     }
   }
 
   resetForTest(): void {
-    const scripts = Array.from(this.#acceptedScripts);
-    for (const script of scripts) {
-      void this.removeScript(script);
-    }
+    this.globalObjectCleared();
   }
 
   dispose(): void {
     Common.EventTarget.removeEventListeners(this.#eventListeners);
-    const scripts = Array.from(this.#acceptedScripts);
-    for (const script of scripts) {
-      void this.removeScript(script);
-    }
+    this.globalObjectCleared();
     for (const project of this.#projects.values()) {
       project.removeProject();
     }