chrome-devtools-frontend 1.0.1706026 → 1.0.1709383

package/front_end/core/sdk/DebuggerModel.ts

@@ -134,6 +134,31 @@ export const enum StepMode {
   STEP_OVER = 'StepOver',
 }
 
+/** A CDP step command. `ranges` is passed as `skipList` to stepInto/stepOver, and ignored for stepOut. */
+export interface AutoStep {
+  readonly command: StepMode;
+  readonly ranges: readonly LocationRange[];
+}
+
+/**
+ * The step the user requested. It lives until a pause is presented to the user, or the user resumes or pauses, and
+ * allows the before-paused callback to continue the step automatically.
+ */
+export interface StepContext {
+  readonly mode: StepMode;
+  /** The call frames of the pause in which the user requested the step. */
+  readonly callFrames: readonly CallFrame[];
+}
+
+/** Computes the CDP step command for a user-requested step. */
+export type ComputeAutoStepCallback = (mode: StepMode, callFrames: readonly CallFrame[]) => Promise<AutoStep>;
+
+/**
+ * Invoked for every pause before it's presented. Returns null to present the pause, or the step to issue instead.
+ */
+export type BeforePausedCallback = (details: DebuggerPausedDetails, context: StepContext|null) =>
+    Promise<AutoStep|null>;
+
 export const WASM_SYMBOLS_PRIORITY: Protocol.Debugger.DebugSymbolsType[] = [
   Protocol.Debugger.DebugSymbolsType.ExternalDWARF,
   Protocol.Debugger.DebugSymbolsType.EmbeddedDWARF,
@@ -166,20 +191,15 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   readonly #jsSourceMapsEnabledSetting: Common.Settings.Setting<boolean>;
   readonly #skipAllPausesSetting: Common.Settings.Setting<boolean>;
   #skipAllPausesTimeout?: ReturnType<typeof setTimeout>;
-  #beforePausedCallback: ((arg0: DebuggerPausedDetails, stepOver: Location|null) => Promise<boolean>)|null = null;
-  #computeAutoStepRangesCallback: ((arg0: StepMode, arg1: CallFrame) => Promise<Array<{
-                                     start: Location,
-                                     end: Location,
-                                   }>>)|null = null;
+  #beforePausedCallback: BeforePausedCallback|null = null;
+  #computeAutoStepCallback: ComputeAutoStepCallback|null = null;
   evaluateOnCallFrameCallback:
       ((arg0: CallFrame, arg1: EvaluationOptions) => Promise<EvaluationResult|null>)|null = null;
   #synchronizeBreakpointsCallback: ((script: Script) => Promise<void>)|null = null;
   // We need to be able to register listeners for individual breakpoints. As such, we dispatch
   // on breakpoint ids, which are not statically known. The event #payload will always be a `Location`.
   readonly #breakpointResolvedEventTarget = new Common.ObjectWrapper.ObjectWrapper<Record<string, Location>>();
-  // When stepping over with autostepping enabled, the context denotes the function to which autostepping is restricted
-  // to by way of its functionLocation (as per Debugger.CallFrame).
-  #autoSteppingContext: Location|null = null;
+  #stepContext: StepContext|null = null;
   #isPausing = false;
 
   constructor(target: Target) {
@@ -429,58 +449,63 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     void this.agent.invoke_setBreakpointsActive({active: this.#breakpointsActiveSetting.get()});
   }
 
-  setComputeAutoStepRangesCallback(callback: ((arg0: StepMode, arg1: CallFrame) => Promise<LocationRange[]>)|null):
-      void {
-    this.#computeAutoStepRangesCallback = callback;
-  }
-
-  private async computeAutoStepSkipList(mode: StepMode): Promise<Protocol.Debugger.LocationRange[]> {
-    let ranges: LocationRange[] = [];
-    if (this.#computeAutoStepRangesCallback && this.#debuggerPausedDetails &&
-        this.#debuggerPausedDetails.callFrames.length > 0) {
-      const [callFrame] = this.#debuggerPausedDetails.callFrames;
-      ranges = await this.#computeAutoStepRangesCallback.call(null, mode, callFrame);
-    }
-    const skipList = ranges.map(({start, end}) => ({
-                                  scriptId: start.scriptId,
-                                  start: {lineNumber: start.lineNumber, columnNumber: start.columnNumber},
-                                  end: {lineNumber: end.lineNumber, columnNumber: end.columnNumber},
-                                }));
-    return sortAndMergeRanges(skipList);
+  setComputeAutoStepCallback(callback: ComputeAutoStepCallback|null): void {
+    this.#computeAutoStepCallback = callback;
   }
 
   async stepInto(): Promise<void> {
-    const skipList = await this.computeAutoStepSkipList(StepMode.STEP_INTO);
-    void this.agent.invoke_stepInto({breakOnAsyncCall: false, skipList});
+    await this.#userStep(StepMode.STEP_INTO);
   }
 
   async stepOver(): Promise<void> {
-    this.#autoSteppingContext = this.#debuggerPausedDetails?.callFrames[0]?.functionLocation() ?? null;
-    const skipList = await this.computeAutoStepSkipList(StepMode.STEP_OVER);
-    void this.agent.invoke_stepOver({skipList});
+    await this.#userStep(StepMode.STEP_OVER);
   }
 
   async stepOut(): Promise<void> {
-    const skipList = await this.computeAutoStepSkipList(StepMode.STEP_OUT);
-    if (skipList.length !== 0) {
-      void this.agent.invoke_stepOver({skipList});
-    } else {
-      void this.agent.invoke_stepOut();
-    }
+    await this.#userStep(StepMode.STEP_OUT);
   }
 
   scheduleStepIntoAsync(): void {
-    void this.computeAutoStepSkipList(StepMode.STEP_INTO).then(skipList => {
-      void this.agent.invoke_stepInto({breakOnAsyncCall: true, skipList});
-    });
+    void this.#userStep(StepMode.STEP_INTO, /* breakOnAsyncCall */ true);
+  }
+
+  async #userStep(mode: StepMode, breakOnAsyncCall = false): Promise<void> {
+    const callFrames = this.#debuggerPausedDetails?.callFrames ?? [];
+    this.#stepContext = {mode, callFrames};
+    const step = this.#computeAutoStepCallback && callFrames.length > 0 ?
+        await this.#computeAutoStepCallback(mode, callFrames) :
+        {command: mode, ranges: []};
+    this.#issueStep(step, breakOnAsyncCall);
+  }
+
+  #issueStep({command, ranges}: AutoStep, breakOnAsyncCall = false): void {
+    const skipList =
+        sortAndMergeRanges(ranges.map(({start, end}) => ({
+                                        scriptId: start.scriptId,
+                                        start: {lineNumber: start.lineNumber, columnNumber: start.columnNumber},
+                                        end: {lineNumber: end.lineNumber, columnNumber: end.columnNumber},
+                                      })));
+    switch (command) {
+      case StepMode.STEP_INTO:
+        void this.agent.invoke_stepInto({breakOnAsyncCall, skipList});
+        break;
+      case StepMode.STEP_OVER:
+        void this.agent.invoke_stepOver({skipList});
+        break;
+      case StepMode.STEP_OUT:
+        void this.agent.invoke_stepOut();
+        break;
+    }
   }
 
   resume(): void {
+    this.#stepContext = null;
     void this.agent.invoke_resume({terminateOnResume: false});
     this.#isPausing = false;
   }
 
   pause(): void {
+    this.#stepContext = null;
     this.#isPausing = true;
     this.skipAllPauses(false);
     void this.agent.invoke_pause();
@@ -569,7 +594,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.#scripts.clear();
     this.#scriptsBySourceURL.clear();
     this.#discardableScripts = [];
-    this.#autoSteppingContext = null;
+    this.#stepContext = null;
   }
 
   scripts(): Script[] {
@@ -611,20 +636,22 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     return this.#debuggerPausedDetails;
   }
 
-  private async setDebuggerPausedDetails(debuggerPausedDetails: DebuggerPausedDetails): Promise<boolean> {
+  /**
+   * @returns null if the pause was presented, or the step to issue instead, as decided by the before-paused callback.
+   */
+  private async setDebuggerPausedDetails(debuggerPausedDetails: DebuggerPausedDetails): Promise<AutoStep|null> {
     this.#isPausing = false;
     this.#debuggerPausedDetails = debuggerPausedDetails;
     if (this.#beforePausedCallback) {
-      if (!await this.#beforePausedCallback.call(null, debuggerPausedDetails, this.#autoSteppingContext)) {
-        return false;
+      const autoStep = await this.#beforePausedCallback(debuggerPausedDetails, this.#stepContext);
+      if (autoStep) {
+        return autoStep;
       }
     }
-    // If we resolved a location in auto-stepping callback, reset the
-    // auto-step-over context.
-    this.#autoSteppingContext = null;
+    this.#stepContext = null;
     this.dispatchEventToListeners(Events.DebuggerPaused, this);
     this.setSelectedCallFrame(debuggerPausedDetails.callFrames[0]);
-    return true;
+    return null;
   }
 
   private resetDebuggerPausedDetails(): void {
@@ -633,8 +660,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.setSelectedCallFrame(null);
   }
 
-  setBeforePausedCallback(
-      callback: ((arg0: DebuggerPausedDetails, autoSteppingContext: Location|null) => Promise<boolean>)|null): void {
+  setBeforePausedCallback(callback: BeforePausedCallback|null): void {
     this.#beforePausedCallback = callback;
   }
 
@@ -676,12 +702,9 @@ export class DebuggerModel extends SDKModel<EventTypes> {
       }
     }
 
-    if (!await this.setDebuggerPausedDetails(pausedDetails)) {
-      if (this.#autoSteppingContext) {
-        void this.stepOver();
-      } else {
-        void this.stepInto();
-      }
+    const autoStep = await this.setDebuggerPausedDetails(pausedDetails);
+    if (autoStep) {
+      this.#issueStep(autoStep);
     }
   }
 
@@ -1480,6 +1503,17 @@ export class Scope implements ScopeChainEntry {
     return undefined;
   }
 
+  /**
+   * Present iff V8 has no variable values to show for this scope, either because the scope
+   * declares no variables or because all of them are unavailable (e.g. optimized out).
+   *
+   * Such scopes are retained in {@link CallFrame.scopeChain} so they can be addressed via
+   * `scopeNumber` in `Debugger.evaluateOnCallFrame` and matched against source map scopes.
+   */
+  emptyReason(): Protocol.Debugger.ScopeEmptyReason|undefined {
+    return this.#payload.emptyReason;
+  }
+
   extraProperties(): RemoteObjectProperty[] {
     if (this !== this.#callFrame.localScope() || this.#callFrame.script.isWasm()) {
       return [];

package/front_end/core/sdk/NetworkRequest.ts

@@ -179,6 +179,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
   #blockedReason: Protocol.Network.BlockedReason|undefined = undefined;
   #renderBlockingBehavior?: Protocol.Network.RenderBlockingBehavior;
   #initiatorSecurityOrigin?: SecurityOrigin;
+  #requestURLSecurityOrigin?: SecurityOrigin;
   #corsErrorStatus: Protocol.Network.CorsErrorStatus|undefined = undefined;
   statusCode = 0;
   statusText = '';
@@ -193,6 +194,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
   #resourceType: Common.ResourceType.ResourceType = Common.ResourceType.resourceTypes.Other;
   #contentData: Promise<TextUtils.ContentData.ContentDataOrError>|null = null;
   #streamingContentData: Promise<TextUtils.StreamingContentData.StreamingContentDataOrError>|null = null;
+  #resolvedStreamingContentData: TextUtils.StreamingContentData.StreamingContentData|null = null;
   readonly #frames: WebSocketFrame[] = [];
   #responseHeaderValues: Record<string, string|undefined> = {};
   #responseHeadersText = '';
@@ -268,7 +270,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
   /**
    * Whether this request was imported from a HAR file.
    */
-  #isImportedHar = false;
+  readonly #isImportedHar: boolean;
   #associatedData = new Map<string, object>();
   #hasOverriddenContent = false;
   #hasThirdPartyCookiePhaseoutIssue = false;
@@ -293,6 +295,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
       hasUserGesture?: boolean,
       // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       console: Common.Console.Console = Common.Console.Console.instance(),
+      isImportedHar = false,
   ) {
     super();
 
@@ -307,6 +310,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.#isAdRelated = false;
     this.#isLinkPreload = false;
     this.#console = console;
+    this.#isImportedHar = isImportedHar;
   }
 
   static create(
@@ -371,6 +375,36 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     );
   }
 
+  /**
+   * Creates a network request representing an entry imported from a HAR file.
+   *
+   * Use this instead of {@link createWithoutBackendRequest} when importing HAR logs
+   * (or testing HAR-imported traffic) so that the request is marked as HAR-imported
+   * at construction time and its security origins ({@link requestURLSecurityOrigin}
+   * and {@link initiatorSecurityOrigin}) resolve to isolated `imported-har://`
+   * virtual origins rather than colliding with live web origins.
+   */
+  static createForImportedHar(
+      requestId: string,
+      url: Platform.DevToolsPath.UrlString,
+      documentURL: Platform.DevToolsPath.UrlString,
+      initiator: Protocol.Network.Initiator|null,
+      console?: Common.Console.Console,
+      ): NetworkRequest {
+    return new NetworkRequest(
+        requestId,
+        undefined,
+        url,
+        documentURL,
+        null,
+        null,
+        initiator,
+        undefined,
+        console,
+        true,
+    );
+  }
+
   identityCompare(other: NetworkRequest): number {
     const thisId = this.requestId();
     const thatId = other.requestId();
@@ -402,10 +436,16 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
    * (`imported-har://${authority}`) to ensure recorded network traffic never collides with
    * live web origins.
    *
+   * The result is cached, so repeated calls return the same instance until the URL changes.
+   * This keeps opaque origins (such as `data:` URLs) same-origin with themselves.
+   *
    * @see {@link initiatorSecurityOrigin} to obtain the origin of the document that initiated the request.
    */
   requestURLSecurityOrigin(): SecurityOrigin {
-    return this.#resolveSecurityOrigin(this.#url);
+    if (!this.#requestURLSecurityOrigin) {
+      this.#requestURLSecurityOrigin = this.#resolveSecurityOrigin(this.#url);
+    }
+    return this.#requestURLSecurityOrigin;
   }
 
   /**
@@ -422,6 +462,9 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
    * For imported HAR files, the origin is mapped to an isolated virtual domain
    * (`imported-har://${authority}`) matching the imported initiating document.
    *
+   * The result is cached, so repeated calls return the same instance. This keeps opaque
+   * origins same-origin with themselves.
+   *
    * @see {@link requestURLSecurityOrigin} to obtain the origin of the target resource URL being requested.
    */
   initiatorSecurityOrigin(): SecurityOrigin {
@@ -462,6 +505,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.#parsedQueryParameters = undefined;
     this.#name = undefined;
     this.#path = undefined;
+    this.#requestURLSecurityOrigin = undefined;
   }
 
   get documentURL(): Platform.DevToolsPath.UrlString {
@@ -1206,10 +1250,6 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     return this.#isImportedHar;
   }
 
-  setIsImportedHar(isImportedHar: boolean): void {
-    this.#isImportedHar = isImportedHar;
-  }
-
   setEarlyHintsHeaders(headers: NameValue[]): void {
     this.earlyHintsHeaders = headers;
   }
@@ -1488,9 +1528,11 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
       }
       // Note that this is save: "streamResponseBody()" always creates base64-based ContentData and
       // for "contentData()" we'll never call "addChunk".
-      return TextUtils.StreamingContentData.StreamingContentData.from(
+      const streamingContentData = TextUtils.StreamingContentData.StreamingContentData.from(
           contentData,
       );
+      this.#resolvedStreamingContentData = streamingContentData;
+      return streamingContentData;
     });
 
     return this.#streamingContentData;
@@ -1510,6 +1552,18 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
       isRegex: boolean,
       ): Promise<TextUtils.ContentProvider.SearchMatch[]> {
     if (!this.#contentDataProvider) {
+      const cachedContentData = this.finished && !this.failed ?
+          (await this.#contentData ?? this.#resolvedStreamingContentData?.content()) :
+          undefined;
+      if (cachedContentData && !TextUtils.ContentData.ContentData.isError(cachedContentData) &&
+          cachedContentData.isTextContent) {
+        return TextUtils.TextUtils.performSearchInContentData(
+            cachedContentData,
+            query,
+            caseSensitive,
+            isRegex,
+        );
+      }
       return await NetworkManager.searchInRequest(
           this,
           query,
@@ -1940,11 +1994,15 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     }
     this.endTime = timestamp;
     if (data) {
-      void this.#streamingContentData?.then(contentData => {
-        if (!TextUtils.StreamingContentData.isError(contentData)) {
-          contentData.addChunk(data);
-        }
-      });
+      if (this.#resolvedStreamingContentData) {
+        this.#resolvedStreamingContentData.addChunk(data);
+      } else {
+        void this.#streamingContentData?.then(contentData => {
+          if (!TextUtils.StreamingContentData.isError(contentData)) {
+            contentData.addChunk(data);
+          }
+        });
+      }
     }
   }
 

package/front_end/core/sdk/OverlayModel.ts

@@ -662,6 +662,18 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
           color: Common.Color.PageHighlight.LayoutLine.toProtocolRGBA(),
         },
       };
+
+      highlightConfig.imcbHighlightConfig = {
+        imcbBorderColor: Common.Color.PageHighlight.AnchorIMCB.toProtocolRGBA(),
+        imcbBackgroundColor: Common.Color.PageHighlight.AnchorIMCBBackground.toProtocolRGBA(),
+        insetsBackgroundColor: Common.Color.PageHighlight.AnchorInsetsBackground.toProtocolRGBA(),
+        insetsHatchColor: Common.Color.PageHighlight.AnchorInsetsHatch.toProtocolRGBA(),
+        anchorBorderColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        anchorBackgroundColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+        showPositionAreaGrid: true,
+        positionAreaGridLineColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        positionAreaActiveRegionColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+      };
     }
 
     if (mode.endsWith('gap')) {
@@ -793,6 +805,41 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
       };
     }
 
+    const baseImcbHighlightConfig = {
+      imcbBorderColor: Common.Color.PageHighlight.AnchorIMCB.toProtocolRGBA(),
+      imcbBackgroundColor: Common.Color.PageHighlight.AnchorIMCBBackground.toProtocolRGBA(),
+      anchorBorderColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+      anchorBackgroundColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+    };
+
+    if (mode === 'anchor-positioning') {
+      highlightConfig.imcbHighlightConfig = {
+        ...baseImcbHighlightConfig,
+        insetsBackgroundColor: Common.Color.PageHighlight.AnchorInsetsBackground.toProtocolRGBA(),
+        insetsHatchColor: Common.Color.PageHighlight.AnchorInsetsHatch.toProtocolRGBA(),
+        showPositionAreaGrid: true,
+        positionAreaGridLineColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        positionAreaActiveRegionColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+      };
+    }
+
+    if (mode === 'position-area') {
+      highlightConfig.imcbHighlightConfig = {
+        ...baseImcbHighlightConfig,
+        showPositionAreaGrid: true,
+        positionAreaGridLineColor: Common.Color.PageHighlight.AnchorTarget.toProtocolRGBA(),
+        positionAreaActiveRegionColor: Common.Color.PageHighlight.AnchorTargetBackground.toProtocolRGBA(),
+      };
+    }
+
+    if (mode === 'insets') {
+      highlightConfig.imcbHighlightConfig = {
+        ...baseImcbHighlightConfig,
+        insetsBackgroundColor: Common.Color.PageHighlight.AnchorInsetsBackground.toProtocolRGBA(),
+        insetsHatchColor: Common.Color.PageHighlight.AnchorInsetsHatch.toProtocolRGBA(),
+      };
+    }
+
     return highlightConfig;
   }
 

package/front_end/core/sdk/PageResourceLoader.ts

@@ -317,6 +317,29 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     }
   }
 
+  #resolveFrameTarget(initiator: PageResourceLoadInitiator): {
+    frameTarget: Target|null,
+    frameId: Protocol.Page.FrameId|null,
+  } {
+    let frameTarget: Target|null = initiator.target;
+    let parentFrameId: Protocol.Page.FrameId|null = null;
+    while (frameTarget && !frameTarget.model(ResourceTreeModel)) {
+      parentFrameId = parentFrameId ?? frameTarget.targetInfo()?.parentFrameId ?? null;
+      frameTarget = frameTarget.parentTarget();
+    }
+    const frameId = initiator.frameId ?? parentFrameId ?? frameTarget?.model(ResourceTreeModel)?.mainFrame?.id ?? null;
+    return {frameTarget, frameId};
+  }
+
+  #isSameOriginWithPrimaryPage(frameTarget: Target|null, frameId: Protocol.Page.FrameId|null): boolean {
+    const primaryFrame = this.#targetManager.primaryPageTarget()?.model(ResourceTreeModel)?.mainFrame;
+    const initiatorFrame = frameId ? frameTarget?.model(ResourceTreeModel)?.frameForId(frameId) : null;
+    if (!primaryFrame || !initiatorFrame) {
+      return false;
+    }
+    return initiatorFrame.securityOrigin().isSameOriginWith(primaryFrame.securityOrigin());
+  }
+
   private async dispatchLoad(
       url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary: boolean): Promise<{
     success: boolean,
@@ -343,11 +366,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       // directive is present. A null/error response keeps the guard armed so that a
       // detached-frame or protocol-error path cannot fall through to loadFromHostBindings.
       let mustEnforceCSP = isHttp;
-      let frameTarget: Target|null = initiator.target;
-      while (frameTarget && !frameTarget.model(ResourceTreeModel)) {
-        frameTarget = frameTarget.parentTarget();
-      }
-      const frameId = initiator.frameId ?? frameTarget?.model(ResourceTreeModel)?.mainFrame?.id ?? null;
+      const {frameTarget, frameId} = this.#resolveFrameTarget(initiator);
       if (isHttp && frameTarget) {
         const networkManager = frameTarget.model(NetworkManager);
         if (networkManager) {
@@ -366,7 +385,8 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       } catch (e) {
         if (e instanceof Error) {
           Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FAILURE);
-          if (mustEnforceCSP || e.message.includes('CSP violation')) {
+          if (mustEnforceCSP || !this.#isSameOriginWithPrimaryPage(frameTarget, frameId) ||
+              e.message.includes('CSP violation')) {
             return {
               success: false,
               content: '',

package/front_end/core/sdk/SourceMap.ts

@@ -12,7 +12,12 @@ import {scopeTreeForScript} from './ScopeTreeCache.js';
 import type {Script} from './Script.js';
 import {buildOriginalScopes, decodePastaRanges, type NamedFunctionRange} from './SourceMapFunctionRanges.js';
 import {decodeRangeMappings} from './SourceMapRangeMappings.js';
-import {scriptRelativePosition, SourceMapScopesInfo, type TranslatedFrame} from './SourceMapScopesInfo.js';
+import {
+  type PositionRange,
+  type RawFrameTranslation,
+  scriptRelativePosition,
+  SourceMapScopesInfo,
+} from './SourceMapScopesInfo.js';
 
 /**
  * Type of the base source map JSON object, which contains the sources and the mappings at the very least, plus
@@ -250,6 +255,16 @@ export class SourceMap {
     return this.#scopesInfo !== null && !this.#scopesInfo.isEmpty();
   }
 
+  /**
+   * True iff the scopes come from the source map itself (encoded `scopes`), not from the AST fallback or from an
+   * extension.
+   */
+  hasEncodedScopeInfo(): boolean {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo !== null && this.#scopesFallbackPromise === undefined &&
+        this.#scopesInfo.hasGeneratedRanges();
+  }
+
   waitForScopeInfo(): Promise<void> {
     this.#ensureSourceMapProcessed();
     return this.#scopesFallbackPromise ?? Promise.resolve();
@@ -867,19 +882,32 @@ export class SourceMap {
     return this.#scopesInfo?.findOriginalFunctionScope(position) ?? null;
   }
 
-  isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
+  /** See {@link SourceMapScopesInfo.translateRawFrame}. `null` if no scopes information is available. */
+  translateRawFrame(generatedLine: number, generatedColumn: number): RawFrameTranslation|null {
     this.#ensureSourceMapProcessed();
-    return this.#scopesInfo?.isOutlinedFrame(generatedLine, generatedColumn) ?? false;
+    return this.#scopesInfo?.translateRawFrame(generatedLine, generatedColumn) ?? null;
   }
 
-  hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean {
-    this.#ensureSourceMapProcessed();
-    return this.#scopesInfo?.hasInlinedFrames(generatedLine, generatedColumn) ?? false;
+  /** See {@link SourceMapScopesInfo.inlinedFunctionRange}. `null` without encoded scopes. */
+  inlinedFunctionRange(generatedLine: number, generatedColumn: number): PositionRange|null {
+    return this.hasEncodedScopeInfo() ? this.#scopesInfo?.inlinedFunctionRange(generatedLine, generatedColumn) ?? null :
+                                        null;
   }
 
-  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
-    this.#ensureSourceMapProcessed();
-    return this.#scopesInfo?.translateCallSite(generatedLine, generatedColumn) ?? [];
+  /** See {@link SourceMapScopesInfo.inlinedCalleeRanges}. Empty without encoded scopes. */
+  inlinedCalleeRanges(generatedLine: number, generatedColumn: number): PositionRange[] {
+    return this.hasEncodedScopeInfo() ? this.#scopesInfo?.inlinedCalleeRanges(generatedLine, generatedColumn) ?? [] :
+                                        [];
+  }
+
+  /** See {@link SourceMapScopesInfo.hasOutlinedFunctions}. False without encoded scopes. */
+  hasOutlinedFunctions(): boolean {
+    return this.hasEncodedScopeInfo() && (this.#scopesInfo?.hasOutlinedFunctions() ?? false);
+  }
+
+  /** See {@link SourceMapScopesInfo.artificialFunctionRanges}. Empty without encoded scopes. */
+  artificialFunctionRanges(): PositionRange[] {
+    return this.hasEncodedScopeInfo() ? this.#scopesInfo?.artificialFunctionRanges() ?? [] : [];
   }
 }