chrome-devtools-frontend 1.0.1699061 → 1.0.1701636

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -14,6 +14,19 @@ import {type DebuggerSourceMapping, DebuggerWorkspaceBinding} from './DebuggerWo
 import {NetworkProject} from './NetworkProject.js';
 import {metadataForURL} from './ResourceUtils.js';
 
+/**
+ * The security origin of the URL that `target` (or its closest ancestor that has
+ * one) is inspecting, or `null` if none of them has an inspected URL yet.
+ */
+function inspectedSecurityOrigin(target: SDK.Target.Target): SDK.SecurityOrigin.SecurityOrigin|null {
+  for (let current: SDK.Target.Target|null = target; current; current = current.parentTarget()) {
+    if (current.inspectedURL()) {
+      return current.inspectedSecurityOrigin();
+    }
+  }
+  return null;
+}
+
 export class ResourceScriptMapping implements DebuggerSourceMapping {
   readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
   #workspace: Workspace.Workspace.WorkspaceImpl;
@@ -197,6 +210,19 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
       // Try to resolve `//# sourceURL=` annotations relative to
       // the base URL, according to the sourcemap specification.
       url = SDK.SourceMapManager.SourceMapManager.resolveRelativeSourceURL(script.debuggerModel.target(), url);
+
+      // `//# sourceURL=` annotations are fully controlled by the page, so don't let
+      // them impersonate a resource of a different origin (b/553931271).
+      if (!this.#isTrustworthySourceURL(script, url)) {
+        return;
+      }
+
+      // Don't let a synthetic source evict the `UISourceCode` of a script that was
+      // actually fetched from the network under the same URL.
+      const previousUISourceCode = this.project(script).uiSourceCodeForURL(url);
+      if (previousUISourceCode && !NetworkProject.isSourceURLSynthesized(previousUISourceCode)) {
+        return;
+      }
     } else {
       // Ignore inline <script>s without `//# sourceURL` annotation here.
       if (script.isInlineScript()) {
@@ -225,6 +251,9 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     // Create UISourceCode.
     const originalContentProvider = script.originalContentProvider();
     const uiSourceCode = project.createUISourceCode(url, originalContentProvider.contentType());
+    if (script.hasSourceURL) {
+      NetworkProject.setSourceURLSynthesized(uiSourceCode);
+    }
     NetworkProject.setInitialFrameAttribution(uiSourceCode, script.frameId);
     const metadata = metadataForURL(this.debuggerModel.target(), script.frameId, url);
 
@@ -238,6 +267,39 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     void this.debuggerWorkspaceBinding.updateLocations(script);
   }
 
+  /**
+   * Whether the (already resolved) `//# sourceURL=` annotation `url` of `script` may
+   * be used as-is.
+   *
+   * Only `http(s)` URLs can collide with genuine network resources, so an origin is
+   * only enforced for those. Annotations using other schemes (e.g. `webpack-internal://`,
+   * `snippet://` or `chrome-extension://` for content scripts) cannot impersonate a
+   * network resource and are always accepted.
+   *
+   * The origin of the script's frame is authoritative. For targets that don't have a
+   * frame (e.g. workers) we fall back to the inspected URL of the target (or of its
+   * closest ancestor that has one). If no origin can be established at all, the
+   * annotation is rejected, since we cannot rule out that it spoofs another origin.
+   */
+  #isTrustworthySourceURL(script: SDK.Script.Script, url: Platform.DevToolsPath.UrlString): boolean {
+    if (script.isContentScript()) {
+      return true;
+    }
+    const parsedURL = Common.ParsedURL.ParsedURL.fromString(url);
+    if (!parsedURL || !['http', 'https'].includes(parsedURL.scheme)) {
+      return true;
+    }
+    const target = script.debuggerModel.target();
+    const frame = script.frameId ?
+        target.model(SDK.ResourceTreeModel.ResourceTreeModel)?.frameForId(script.frameId) ?? null :
+        null;
+    const securityOrigin = frame ? frame.securityOrigin() : inspectedSecurityOrigin(target);
+    if (!securityOrigin) {
+      return false;
+    }
+    return SDK.SecurityOrigin.SecurityOrigin.create(url).isSameOriginWith(securityOrigin);
+  }
+
   scriptFile(uiSourceCode: Workspace.UISourceCode.UISourceCode): ResourceScriptFile|null {
     return this.#uiSourceCodeToScriptFile.get(uiSourceCode) || null;
   }

package/front_end/models/change_tracker/ChangeTracker.ts

@@ -25,7 +25,7 @@ export class ChangeTracker {
   }
 
   get isTracking(): boolean {
-    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled);
+    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled) && this.#commentManager.isAgentAttached();
   }
 
   trackChange(

package/front_end/models/comment_manager/CD4ABridge.ts

@@ -72,7 +72,7 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     if (!this.#targetManager) {
       return undefined;
     }
-    const target = this.#targetManager.targetById(nodeSignature.targetId) ?? this.#targetManager.primaryPageTarget();
+    const target = this.#targetManager.targetById(nodeSignature.targetId);
     const domModel = target?.model(SDK.DOMModel.DOMModel);
     if (!domModel) {
       return undefined;
@@ -132,8 +132,8 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     });
   }
 
-  takeComments(): CommentThread[] {
-    return this.getCommentThreads();
+  setAgentAttached(value: boolean): void {
+    this.#commentManager.setAgentAttached(value);
   }
 
   resolveCommentThread(threadId: string, replyText?: string): boolean {
@@ -156,7 +156,7 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     }
 
     if (target?.node && this.#targetManager) {
-      const sdkTarget = this.#targetManager.targetById(target.node.targetId) ?? this.#targetManager.primaryPageTarget();
+      const sdkTarget = this.#targetManager.targetById(target.node.targetId);
       const domModel = sdkTarget?.model(SDK.DOMModel.DOMModel);
       if (domModel) {
         const cdpNodeId = target.node.backendNodeId as Protocol.DOM.BackendNodeId;

package/front_end/models/comment_manager/CommentManager.ts

@@ -32,11 +32,13 @@ export {
 export const enum Events {
   COMMENT_THREADS_CHANGED = 'CommentThreadsChanged',
   COMMENT_MODE_CHANGED = 'CommentModeChanged',
+  AGENT_ATTACHED_CHANGED = 'AgentAttachedChanged',
 }
 
 export interface EventTypes {
   [Events.COMMENT_THREADS_CHANGED]: CommentThread[];
   [Events.COMMENT_MODE_CHANGED]: boolean;
+  [Events.AGENT_ATTACHED_CHANGED]: boolean;
 }
 
 /**
@@ -45,6 +47,7 @@ export interface EventTypes {
 export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #commentThreads = new Map<string, CommentThread>();
   #commentMode = false;
+  #agentAttached = false;
 
   constructor() {
     super();
@@ -55,7 +58,25 @@ export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
   }
 
+  setAgentAttached(value: boolean): void {
+    if (this.#agentAttached === value) {
+      return;
+    }
+    this.#agentAttached = value;
+    if (!value) {
+      this.setCommentMode(false);
+    }
+    this.dispatchEventToListeners(Events.AGENT_ATTACHED_CHANGED, value);
+  }
+
+  isAgentAttached(): boolean {
+    return this.#agentAttached;
+  }
+
   setCommentMode(active: boolean): void {
+    if (active && !this.#agentAttached) {
+      return;
+    }
     if (this.#commentMode === active) {
       return;
     }

package/front_end/models/extensions/ExtensionAPI.ts

@@ -1586,8 +1586,10 @@ globalThis.injectedExtensionAPI = function(
     const targetDocument = targetWindowForTest?.document ?? document;
     const focused = targetDocument.activeElement;
     if (focused) {
-      const isInput =
-          focused.nodeName === 'INPUT' || focused.nodeName === 'TEXTAREA' || (focused as HTMLElement).isContentEditable;
+      // Elements made editable through the EditContext API are not reported as contentEditable.
+      const hasEditContext = 'editContext' in focused && Boolean(focused.editContext);
+      const isInput = focused.nodeName === 'INPUT' || focused.nodeName === 'TEXTAREA' ||
+          (focused as HTMLElement).isContentEditable || hasEditContext;
       if (isInput && !(requestPayload.ctrlKey || requestPayload.altKey || requestPayload.metaKey)) {
         return;
       }

package/front_end/models/formatter/FormatterWorkerPool.ts

@@ -134,8 +134,8 @@ export class FormatterWorkerPool {
     return this.runTask(FormatterActions.FormatterActions.FORMAT, parameters) as Promise<FormatterActions.FormatResult>;
   }
 
-  javaScriptSubstitute(expression: string, mapping: Map<string, string|null>): Promise<string> {
-    if (mapping.size === 0) {
+  javaScriptSubstitute(expression: string, mapping: Array<Map<string, string|null>>): Promise<string> {
+    if (mapping.every(m => m.size === 0)) {
       return Promise.resolve(expression);
     }
     return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SUBSTITUTE, {content: expression, mapping})

package/front_end/models/issues_manager/CookieIssue.ts

@@ -306,8 +306,6 @@ export function isCausedByThirdParty(
   //     site. Only cookies that have their domain also set to this third-party
   //     are included in the request. We assume that the cookie was set by the same
   //     third-party at some point, so we treat this as a third-party issue.
-  //
-  // TODO(crbug.com/1080589): Use "First-Party sets" instead of the sites registered domain.
   return !isSubdomainOf(parsedCookieUrl.domain(), outermostFrame.domainAndRegistry());
 }
 

package/front_end/models/javascript_metadata/NativeFunctions.ts

@@ -1367,6 +1367,11 @@ export const NativeFunctions: readonly NativeFunctionValue[] = [
     signatures: [["message","?options"],["message","transfer"],["message","targetOrigin","?transfer"]],
     receivers: ["Window"]
   },
+  {
+    name: "postMessage",
+    signatures: [["message","targetOrigin"],["message","?options"]],
+    receivers: ["HTMLPersistentWidgetElement","PersistentWidgetOpener"]
+  },
   {
     name: "deleteRule",
     signatures: [["index"]],
@@ -2050,7 +2055,7 @@ export const NativeFunctions: readonly NativeFunctionValue[] = [
   },
   {
     name: "write",
-    signatures: [["...text"],["text"],["text1","...text"]],
+    signatures: [["...text"]],
     receivers: ["Document"]
   },
   {
@@ -2489,7 +2494,7 @@ export const NativeFunctions: readonly NativeFunctionValue[] = [
   },
   {
     name: "writeln",
-    signatures: [["...text"],["text"],["text1","...text"]]
+    signatures: [["...text"]]
   },
   {
     name: "elementFromPoint",

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -9,6 +9,7 @@ import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../../core/text_utils/text_utils.js';
 import * as Protocol from '../../generated/protocol.js';
+import * as Bindings from '../bindings/bindings.js';
 import * as Breakpoints from '../breakpoints/breakpoints.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -431,8 +432,32 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   isUISourceCodeOverridable(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
-    return uiSourceCode.project().type() === Workspace.Workspace.projectTypes.Network &&
-        !NetworkPersistenceManager.isForbiddenNetworkUrl(uiSourceCode.url());
+    if (uiSourceCode.project().type() !== Workspace.Workspace.projectTypes.Network) {
+      return false;
+    }
+    if (NetworkPersistenceManager.isForbiddenNetworkUrl(uiSourceCode.url())) {
+      return false;
+    }
+    // A `//# sourceURL=` annotation is fully controlled by the page and doesn't refer
+    // to an actual network resource, so there is nothing to override here. Persisting
+    // it would poison the overrides folder with a file that masquerades as a genuine
+    // resource (b/553931271).
+    if (Bindings.NetworkProject.NetworkProject.isSourceURLSynthesized(uiSourceCode)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Whether the contents of `uiSourceCode` may be written into the overrides folder.
+   *
+   * Sources that originate from a source map are overridable in the sense that the
+   * deployed resource they are mapped from can be overridden (see
+   * `PersistenceActions`), but their own URL and content are page controlled and
+   * must never be persisted themselves (b/553931271).
+   */
+  #canPersistUISourceCodeAsOverride(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    return this.isUISourceCodeOverridable(uiSourceCode) && !uiSourceCode.contentType().isFromSourceMap();
   }
 
   #isUISourceCodeAlreadyOverridden(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
@@ -445,12 +470,12 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   #canSaveUISourceCodeForOverrides(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
-    return this.#active && this.isUISourceCodeOverridable(uiSourceCode) &&
+    return this.#active && this.#canPersistUISourceCodeAsOverride(uiSourceCode) &&
         !this.#isUISourceCodeAlreadyOverridden(uiSourceCode);
   }
 
   async setupAndStartLocalOverrides(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<boolean> {
-    if (!this.isUISourceCodeOverridable(uiSourceCode)) {
+    if (!this.#canPersistUISourceCodeAsOverride(uiSourceCode)) {
       return false;
     }
     // No overrides folder, set it up

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -15,7 +15,7 @@ interface CachedScopeMap {
 }
 
 const scopeToCachedIdentifiersMap = new WeakMap<Formatter.FormatterWorkerPool.ScopeTreeNode, CachedScopeMap>();
-const cachedMapByCallFrame = new WeakMap<SDK.DebuggerModel.CallFrame, Map<string, string|null>>();
+const cachedMapByCallFrame = new WeakMap<SDK.DebuggerModel.CallFrame, Array<Map<string, string|null>>>();
 
 export async function getTextFor(contentProvider: TextUtils.ContentProvider.ContentProvider):
     Promise<TextUtils.Text.Text|null> {
@@ -401,56 +401,61 @@ export const resolveScopeChain =
           return scopes.map(scope => new ScopeWithSourceMappedVariables(scope, thisObject, debuggerWorkspaceBinding));
         };
 
+function reverseScopeMapping(variableMapping: Map<string, string>): Map<string, string|null> {
+  const result = new Map<string, string|null>();
+  for (const [compiledName, originalName] of variableMapping) {
+    if (originalName && !result.has(originalName)) {
+      result.set(originalName, compiledName);
+    }
+  }
+  return result;
+}
+
 /**
- * @returns A mapping from original name -> compiled name. If the orignal name is unavailable (e.g. because the compiled name was
- * shadowed) we set it to `null`.
+ * @returns An array of mappings (from inner-most to outer-most scope) of original name -> compiled name or binding expression.
  */
 export const allVariablesInCallFrame = async(
     callFrame: SDK.DebuggerModel.CallFrame,
     debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-    Promise<Map<string, string|null>> => {
+    Promise<Array<Map<string, string|null>>> => {
       if (!callFrame.debuggerModel.target()
                .targetManager()
                .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
                .get()) {
-        return new Map<string, string|null>();
+        return [];
+      }
+      const cached = cachedMapByCallFrame.get(callFrame);
+      if (cached) {
+        return cached;
       }
-      const cachedMap = cachedMapByCallFrame.get(callFrame);
-      if (cachedMap) {
-        return cachedMap;
+
+      if (Root.Runtime.hostConfig.devToolsSourceMapScopesInSourcesPanel?.enabled) {
+        const sourceMap = callFrame.script.sourceMap() ??
+            await callFrame.debuggerModel.sourceMapManager().sourceMapForClientPromise(callFrame.script);
+        const mappedVariables =
+            sourceMap?.resolveMappedVariablesAtPosition(callFrame.location(), callFrame.returnValue() !== null);
+        if (mappedVariables) {
+          cachedMapByCallFrame.set(callFrame, mappedVariables);
+          return mappedVariables;
+        }
       }
 
       const scopeChain = callFrame.scopeChain().filter(scope => !scope.empty());
       const nameMappings =
           await Promise.all(scopeChain.map(scope => resolveDebuggerScope(scope, debuggerWorkspaceBinding)));
-      const reverseMapping = new Map<string, string|null>();
-      const compiledNames = new Set<string>();
-      for (const {variableMapping} of nameMappings) {
-        for (const [compiledName, originalName] of variableMapping) {
-          if (!originalName) {
-            continue;
-          }
-          if (!reverseMapping.has(originalName)) {
-            // An inner scope might have shadowed {compiledName}. Mark it as "unavailable" in that case.
-            const compiledNameOrNull = compiledNames.has(compiledName) ? null : compiledName;
-            reverseMapping.set(originalName, compiledNameOrNull);
-          }
-          compiledNames.add(compiledName);
-        }
-      }
+      const reverseMapping = nameMappings.map(({variableMapping}) => reverseScopeMapping(variableMapping));
       cachedMapByCallFrame.set(callFrame, reverseMapping);
       return reverseMapping;
     };
 
 /**
- * @returns A mapping from original name -> compiled name. If the orignal name is unavailable (e.g. because the compiled name was
- * shadowed) we set it to `null`.
+ * @returns An array of mappings (from inner-most to outer-most scope) of original name -> compiled name or binding expression.
  */
 export const allVariablesAtPosition =
     async(location: SDK.DebuggerModel.Location,
           debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-        Promise<Map<string, string|null>> => {
-          const reverseMapping = new Map<string, string|null>();
+        Promise<Array<Map<string, string|null>>> => {
+          const reverseMapping: Array<Map<string, string|null>> = [];
           const script = location.script();
           if (!script) {
             return reverseMapping;
@@ -462,6 +467,15 @@ export const allVariablesAtPosition =
             return reverseMapping;
           }
 
+          if (Root.Runtime.hostConfig.devToolsSourceMapScopesInSourcesPanel?.enabled) {
+            const sourceMap =
+                script.sourceMap() ?? await script.debuggerModel.sourceMapManager().sourceMapForClientPromise(script);
+            const mappedVariables = sourceMap?.resolveMappedVariablesAtPosition(location);
+            if (mappedVariables) {
+              return mappedVariables;
+            }
+          }
+
           const scopeTreeAndText = await computeScopeTree(script);
           if (!scopeTreeAndText) {
             return reverseMapping;
@@ -470,21 +484,10 @@ export const allVariablesAtPosition =
           const {scopeTree, text} = scopeTreeAndText;
           const locationOffset = text.offsetFromPosition(location.lineNumber, location.columnNumber);
           const scopeChain = findScopeChain(scopeTree, {start: locationOffset, end: locationOffset});
-          const compiledNames = new Set<string>();
 
           while (scopeChain.length > 0) {
             const {variableMapping} = await resolveScope(script, scopeChain, debuggerWorkspaceBinding);
-            for (const [compiledName, originalName] of variableMapping) {
-              if (!originalName) {
-                continue;
-              }
-              if (!reverseMapping.has(originalName)) {
-                // An inner scope might have shadowed {compiledName}. Mark it as "unavailable" in that case.
-                const compiledNameOrNull = compiledNames.has(compiledName) ? null : compiledName;
-                reverseMapping.set(originalName, compiledNameOrNull);
-              }
-              compiledNames.add(compiledName);
-            }
+            reverseMapping.push(reverseScopeMapping(variableMapping));
             scopeChain.pop();
           }
           return reverseMapping;
@@ -545,6 +548,7 @@ class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntr
   /** The resolved `this` of the current call frame */
   readonly #thisObject: SDK.RemoteObject.RemoteObject|null;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #object?: SDK.RemoteObject.RemoteObject;
 
   constructor(scope: SDK.DebuggerModel.ScopeChainEntry, thisObject: SDK.RemoteObject.RemoteObject|null,
               debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
@@ -574,7 +578,10 @@ class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntr
   }
 
   object(): SDK.RemoteObject.RemoteObject {
-    return resolveScopeInObject(this.#debuggerScope, this.#debuggerWorkspaceBinding);
+    if (!this.#object) {
+      this.#object = resolveScopeInObject(this.#debuggerScope, this.#debuggerWorkspaceBinding);
+    }
+    return this.#object;
   }
 
   description(): string {
@@ -599,6 +606,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
   private readonly scope: SDK.DebuggerModel.ScopeChainEntry;
   private readonly object: SDK.RemoteObject.RemoteObject;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #allPropertiesPromise?: Promise<SDK.RemoteObject.GetPropertiesResult>;
+  #cachedWithPreview = false;
 
   constructor(scope: SDK.DebuggerModel.ScopeChainEntry,
               debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
@@ -650,6 +659,18 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
 
   override async getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean):
       Promise<SDK.RemoteObject.GetPropertiesResult> {
+    if (accessorPropertiesOnly) {
+      return await this.#resolveAllProperties(true, generatePreview);
+    }
+    if (!this.#allPropertiesPromise || (generatePreview && !this.#cachedWithPreview)) {
+      this.#cachedWithPreview = generatePreview;
+      this.#allPropertiesPromise = this.#resolveAllProperties(false, generatePreview);
+    }
+    return await this.#allPropertiesPromise;
+  }
+
+  async #resolveAllProperties(accessorPropertiesOnly: boolean,
+                              generatePreview: boolean): Promise<SDK.RemoteObject.GetPropertiesResult> {
     const allProperties = await this.object.getAllProperties(accessorPropertiesOnly, generatePreview);
     const {variableMapping} = await resolveDebuggerScope(this.scope, this.#debuggerWorkspaceBinding);
 
@@ -664,6 +685,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
 
   override async setPropertyValue(argumentName: string|Protocol.Runtime.CallArgument, value: string):
       Promise<string|undefined> {
+    this.#allPropertiesPromise = undefined;
+    this.#cachedWithPreview = false;
     const {variableMapping} = await resolveDebuggerScope(this.scope, this.#debuggerWorkspaceBinding);
 
     let name;
@@ -684,6 +707,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
   }
 
   override async deleteProperty(name: Protocol.Runtime.CallArgument): Promise<string|undefined> {
+    this.#allPropertiesPromise = undefined;
+    this.#cachedWithPreview = false;
     return await this.object.deleteProperty(name);
   }
 

package/front_end/models/source_map_scopes/ScopeChainModel.ts

@@ -21,6 +21,9 @@ import {resolveScopeChain} from './NamesResolver.js';
  * This class tracks all that and sends events with the latest scope chain for a specific call frame.
  */
 export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  static readonly #cachedScopeChainByCallFrame =
+      new WeakMap<SDK.DebuggerModel.CallFrame, Promise<SDK.DebuggerModel.ScopeChainEntry[]>>();
+
   readonly #callFrame: SDK.DebuggerModel.CallFrame;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
 
@@ -53,13 +56,29 @@ export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     this.listeners?.clear();
   }
 
+  static resolveScopeChain(callFrame: SDK.DebuggerModel.CallFrame,
+                           debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
+      Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
+    let cachedPromise = ScopeChainModel.#cachedScopeChainByCallFrame.get(callFrame);
+    if (!cachedPromise) {
+      cachedPromise = resolveScopeChain(callFrame, debuggerWorkspaceBinding);
+      ScopeChainModel.#cachedScopeChainByCallFrame.set(callFrame, cachedPromise);
+    }
+    return cachedPromise;
+  }
+
+  resolveScopeChain(): Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
+    return ScopeChainModel.resolveScopeChain(this.#callFrame, this.#debuggerWorkspaceBinding);
+  }
+
   async #update(): Promise<void> {
-    const scopeChain = await resolveScopeChain(this.#callFrame, this.#debuggerWorkspaceBinding);
+    const scopeChain = await this.resolveScopeChain();
     this.dispatchEventToListeners(Events.SCOPE_CHAIN_UPDATED, new ScopeChain(scopeChain));
   }
 
   #debugInfoAttached(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
     if (event.data === this.#callFrame.script) {
+      ScopeChainModel.#cachedScopeChainByCallFrame.delete(this.#callFrame);
       void this.#throttler.schedule(this.#boundUpdate);
     }
   }
@@ -67,6 +86,7 @@ export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   #sourceMapChanged(event: Common.EventTarget
                         .EventTargetEvent<{client: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap}>): void {
     if (event.data.client === this.#callFrame.script) {
+      ScopeChainModel.#cachedScopeChainByCallFrame.delete(this.#callFrame);
       void this.#throttler.schedule(this.#boundUpdate);
     }
   }