chrome-devtools-frontend 1.0.1526630 → 1.0.1529186

package/front_end/core/sdk/NetworkManager.ts

@@ -165,6 +165,8 @@ export class NetworkManager extends SDKModel<EventTypes> {
 
     void this.#networkAgent.invoke_enable({
       maxPostDataSize: MAX_EAGER_POST_REQUEST_BODY_LENGTH,
+      enableDurableMessages: Root.Runtime.hostConfig.devToolsEnableDurableMessages?.enabled,
+      maxTotalBufferSize: MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH,
       reportDirectSocketTraffic: true,
     });
     void this.#networkAgent.invoke_setAttachDebugStack({enabled: true});
@@ -520,6 +522,7 @@ export const Fast4GConditions: Conditions = {
 };
 
 const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;  // bytes
+const MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH = 250 * 1024 * 1024;  // bytes
 
 export class FetchDispatcher implements ProtocolProxyApi.FetchDispatcher {
   readonly #fetchAgent: ProtocolProxyApi.FetchApi;
@@ -1553,6 +1556,254 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   }
 }
 
+type RequestConditionsSetting = {
+  url: string,
+  enabled: boolean,
+}|{
+  urlPattern: URLPatternConstructorString,
+  enabled: boolean,
+};
+
+declare global {
+  // TS typedefs are not up to date
+  interface URLPattern {
+    hash: string;
+    hostname: string;
+    password: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    username: string;
+    hasRegExpGroups: boolean;
+    test(url: string): boolean;
+  }
+  /* eslint-disable-next-line @typescript-eslint/naming-convention */
+  var URLPattern: {prototype: URLPattern, new (input: string): URLPattern};
+}
+
+export type URLPatternConstructorString = Platform.Brand.Brand<string, 'URLPatternConstructorString'>;
+
+export const enum RequestURLPatternValidity {
+  VALID = 'valid',
+  FAILED_TO_PARSE = 'failed-to-parse',
+  HAS_REGEXP_GROUPS = 'has-regexp-groups',
+}
+
+export class RequestURLPattern {
+  private constructor(readonly constructorString: URLPatternConstructorString, readonly pattern: URLPattern) {
+    if (pattern.hasRegExpGroups) {
+      throw new Error('RegExp groups are not allowed');
+    }
+  }
+
+  static isValidPattern(pattern: string): RequestURLPatternValidity {
+    try {
+      const urlPattern = new URLPattern(pattern);
+      return urlPattern.hasRegExpGroups ? RequestURLPatternValidity.HAS_REGEXP_GROUPS : RequestURLPatternValidity.VALID;
+    } catch {
+      return RequestURLPatternValidity.FAILED_TO_PARSE;
+    }
+  }
+
+  static create(constructorString: URLPatternConstructorString): RequestURLPattern|null {
+    try {
+      const urlPattern = new URLPattern(constructorString);
+      return urlPattern.hasRegExpGroups ? null : new RequestURLPattern(constructorString, urlPattern);
+    } catch {
+      return null;
+    }
+  }
+
+  static upgradeFromWildcard(pattern: string): RequestURLPattern|null {
+    const tryCreate = (constructorString: string): RequestURLPattern|null => {
+      const result = this.create(constructorString as URLPatternConstructorString);
+      if (result?.pattern.protocol === 'localhost' && result?.pattern.hostname === '') {
+        // localhost:1234 parses as a valid pattern, do the right thing here instead
+        return tryCreate(`*://${constructorString}`);
+      }
+      return result;
+    };
+
+    return tryCreate(pattern)  // try as is
+        ??
+        // Try to upgrade patterns created from the network panel, which either blocks the full url (sans
+        // protocol) or just the domain name. In both cases the wildcard patterns had implicit wildcards at the end.
+        // We explicitly add that here, which will match both domain names without path (implicitly setting pathname
+        // to '*') and urls with path (appending * to the pathname).
+        tryCreate(`*://${pattern}*`);
+  }
+}
+
+export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<RequestCondition.EventTypes> {
+  #pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern};
+  #enabled: boolean;
+
+  constructor(setting: RequestConditionsSetting) {
+    super();
+    if ('urlPattern' in setting) {
+      this.#pattern = RequestURLPattern.create(setting.urlPattern) ?? {
+        wildcardURL: setting.urlPattern,
+        upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.urlPattern) ?? undefined,
+      };
+    } else {
+      this.#pattern = {
+        wildcardURL: setting.url,
+        upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
+      };
+    }
+    this.#enabled = setting.enabled;
+  }
+
+  get constructorString(): string|undefined {
+    return this.#pattern instanceof RequestURLPattern ? this.#pattern.constructorString :
+                                                        this.#pattern.upgradedPattern?.constructorString;
+  }
+
+  get wildcardURL(): string|undefined {
+    return 'wildcardURL' in this.#pattern ? this.#pattern.wildcardURL : undefined;
+  }
+
+  get constructorStringOrWildcardURL(): string {
+    return this.#pattern instanceof RequestURLPattern ?
+        this.#pattern.constructorString :
+        (this.#pattern.upgradedPattern?.constructorString ?? this.#pattern.wildcardURL);
+  }
+
+  set pattern(pattern: RequestURLPattern|string) {
+    if (typeof pattern === 'string') {
+      // TODO(pfaffe) Remove once the feature flag is no longer required
+      if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+        throw new Error('Should not use wildcard urls');
+      }
+      this.#pattern = {
+        wildcardURL: pattern,
+        upgradedPattern: RequestURLPattern.upgradeFromWildcard(pattern) ?? undefined
+      };
+    } else {
+      this.#pattern = pattern;
+    }
+    this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
+  }
+
+  get enabled(): boolean {
+    return this.#enabled;
+  }
+
+  set enabled(enabled: boolean) {
+    this.#enabled = enabled;
+    this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
+  }
+
+  toSetting(): RequestConditionsSetting {
+    const enabled = this.enabled;
+    return this.#pattern instanceof RequestURLPattern ? {enabled, urlPattern: this.#pattern.constructorString} :
+                                                        {enabled, url: this.#pattern.wildcardURL};
+  }
+
+  get originalOrUpgradedURLPattern(): URLPattern|undefined {
+    return this.#pattern instanceof RequestURLPattern ? this.#pattern.pattern : this.#pattern.upgradedPattern?.pattern;
+  }
+}
+
+export namespace RequestCondition {
+  export const enum Events {
+    REQUEST_CONDITION_CHANGED = 'request-condition-changed',
+  }
+
+  export interface EventTypes {
+    [Events.REQUEST_CONDITION_CHANGED]: void;
+  }
+}
+
+export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<RequestConditions.EventTypes> {
+  readonly #setting =
+      Common.Settings.Settings.instance().createSetting<RequestConditionsSetting[]>('network-blocked-patterns', []);
+  readonly #conditions: RequestCondition[];
+
+  constructor() {
+    super();
+    this.#conditions = this.#setting.get().map(condition => new RequestCondition(condition));
+    for (const condition of this.#conditions) {
+      condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
+    }
+  }
+
+  get count(): number {
+    return this.#conditions.length;
+  }
+
+  findCondition(pattern: string): RequestCondition|undefined {
+    if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+      return this.#conditions.find(condition => condition.constructorString === pattern);
+    }
+    return this.#conditions.find(condition => condition.wildcardURL === pattern);
+  }
+
+  has(url: string): boolean {
+    return Boolean(this.findCondition(url));
+  }
+
+  add(...conditions: RequestCondition[]): void {
+    this.#conditions.push(...conditions);
+    this.#conditionsChanged();
+  }
+
+  delete(condition: RequestCondition): void {
+    const index = this.#conditions.indexOf(condition);
+    if (index < 0) {
+      return;
+    }
+    condition.removeEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
+    this.#conditions.splice(index);
+    this.#conditionsChanged();
+  }
+
+  clear(): void {
+    this.#conditions.splice(0);
+    this.#conditionsChanged();
+    for (const condition of this.#conditions) {
+      condition.removeEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
+    }
+  }
+
+  #conditionsChanged(): void {
+    this.#setting.set(this.#conditions.map(condition => condition.toSetting()));
+    this.dispatchEventToListeners(RequestConditions.Events.REQUEST_CONDITIONS_CHANGED);
+  }
+
+  get conditions(): IteratorObject<RequestCondition> {
+    return this.#conditions.values();
+  }
+
+  applyConditions(...agents: ProtocolProxyApi.NetworkApi[]): boolean {
+    if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+      const urlPatterns = this.#conditions.filter(condition => condition.enabled && condition.constructorString)
+                              .map(condition => ({urlPattern: condition.constructorString as string, block: true}));
+
+      for (const agent of agents) {
+        void agent.invoke_setBlockedURLs({urlPatterns});
+      }
+      return urlPatterns.length > 0;
+    }
+    const urls = this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
+                     .map(condition => condition.wildcardURL as string);
+    for (const agent of agents) {
+      void agent.invoke_setBlockedURLs({urls});
+    }
+    return urls.length > 0;
+  }
+}
+
+export namespace RequestConditions {
+  export const enum Events {
+    REQUEST_CONDITIONS_CHANGED = 'request-conditions-changed',
+  }
+  export interface EventTypes {
+    [Events.REQUEST_CONDITIONS_CHANGED]: void;
+  }
+}
+
 let multiTargetNetworkManagerInstance: MultitargetNetworkManager|null;
 
 export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrapper<MultitargetNetworkManager.EventTypes>
@@ -1567,14 +1818,13 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   #updatingInterceptionPatternsPromise: Promise<void>|null = null;
   readonly #blockingEnabledSetting =
       Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
-  readonly #blockedPatternsSetting =
-      Common.Settings.Settings.instance().createSetting<BlockedPattern[]>('network-blocked-patterns', []);
-  #effectiveBlockedURLs: string[] = [];
+  readonly #requestConditions = new RequestConditions();
   readonly #urlsForRequestInterceptor:
       Platform.MapUtilities.Multimap<(arg0: InterceptedRequest) => Promise<void>, InterceptionPattern> =
       new Platform.MapUtilities.Multimap();
   #extraHeaders?: Protocol.Network.Headers;
   #customUserAgent?: string;
+  #isBlocking = false;
 
   constructor() {
     super();
@@ -1585,7 +1835,8 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       this.dispatchEventToListeners(MultitargetNetworkManager.Events.BLOCKED_PATTERNS_CHANGED);
     };
     this.#blockingEnabledSetting.addChangeListener(blockedPatternChanged);
-    this.#blockedPatternsSetting.addChangeListener(blockedPatternChanged);
+    this.#requestConditions.addEventListener(
+        RequestConditions.Events.REQUEST_CONDITIONS_CHANGED, blockedPatternChanged);
     this.updateBlockedPatterns();
 
     TargetManager.instance().observeModels(NetworkManager, this);
@@ -1653,9 +1904,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       void networkAgent.invoke_setUserAgentOverride(
           {userAgent: this.currentUserAgent(), userAgentMetadata: this.#userAgentMetadataOverride || undefined});
     }
-    if (this.#effectiveBlockedURLs.length) {
-      void networkAgent.invoke_setBlockedURLs({urls: this.#effectiveBlockedURLs});
-    }
+    this.#requestConditions.applyConditions(networkAgent);
     if (this.isIntercepting()) {
       void fetchAgent.invoke_enable({patterns: this.#urlsForRequestInterceptor.valuesArray()});
     }
@@ -1795,9 +2044,8 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     }
   }
 
-  // TODO(allada) Move all request blocking into interception and let view manage blocking.
-  blockedPatterns(): BlockedPattern[] {
-    return this.#blockedPatternsSetting.get().slice();
+  get requestConditions(): RequestConditions {
+    return this.#requestConditions;
   }
 
   blockingEnabled(): boolean {
@@ -1805,11 +2053,16 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   isBlocking(): boolean {
-    return Boolean(this.#effectiveBlockedURLs.length);
+    return this.#isBlocking && this.blockingEnabled();
   }
 
-  setBlockedPatterns(patterns: BlockedPattern[]): void {
-    this.#blockedPatternsSetting.set(patterns);
+  /**
+   * @deprecated Kept for layout tests
+   * TODO(pfaffe) remove
+   */
+  private setBlockedPatterns(patterns: Array<{url: string, enabled: boolean}>): void {
+    this.requestConditions.clear();
+    this.requestConditions.add(...patterns.map(pattern => new RequestCondition(pattern)));
   }
 
   setBlockingEnabled(enabled: boolean): void {
@@ -1820,22 +2073,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   private updateBlockedPatterns(): void {
-    const urls = [];
-    if (this.#blockingEnabledSetting.get()) {
-      for (const pattern of this.#blockedPatternsSetting.get()) {
-        if (pattern.enabled) {
-          urls.push(pattern.url);
-        }
-      }
-    }
-
-    if (!urls.length && !this.#effectiveBlockedURLs.length) {
-      return;
-    }
-    this.#effectiveBlockedURLs = urls;
-    for (const agent of this.#networkAgents) {
-      void agent.invoke_setBlockedURLs({urls: this.#effectiveBlockedURLs});
-    }
+    this.#isBlocking = this.#requestConditions.applyConditions(...this.#networkAgents);
   }
 
   isIntercepting(): boolean {
@@ -2318,11 +2556,6 @@ export interface Conditions {
   targetLatency?: number;
 }
 
-export interface BlockedPattern {
-  url: string;
-  enabled: boolean;
-}
-
 export interface Message {
   message: string;
   requestId: string;

package/front_end/core/sdk/PreloadingModel.ts

@@ -300,15 +300,33 @@ export class PreloadingModel extends SDKModel<EventTypes> {
   onPrerenderStatusUpdated(event: Protocol.Preload.PrerenderStatusUpdatedEvent): void {
     const loaderId = event.key.loaderId;
     this.ensureDocumentPreloadingData(loaderId);
-    const attempt: PrerenderAttemptInternal = {
-      action: Protocol.Preload.SpeculationAction.Prerender,
-      key: event.key,
-      pipelineId: event.pipelineId,
-      status: convertPreloadingStatus(event.status),
-      prerenderStatus: event.prerenderStatus || null,
-      disallowedMojoInterface: event.disallowedMojoInterface || null,
-      mismatchedHeaders: event.mismatchedHeaders || null,
-    };
+    let attempt: PrerenderAttemptInternal|PrerenderUntilScriptAttemptInternal;
+    switch (event.key.action) {
+      case Protocol.Preload.SpeculationAction.Prerender:
+        attempt = {
+          action: event.key.action,
+          key: event.key,
+          pipelineId: event.pipelineId,
+          status: convertPreloadingStatus(event.status),
+          prerenderStatus: event.prerenderStatus || null,
+          disallowedMojoInterface: event.disallowedMojoInterface || null,
+          mismatchedHeaders: event.mismatchedHeaders || null,
+        };
+        break;
+      case Protocol.Preload.SpeculationAction.PrerenderUntilScript:
+        attempt = {
+          action: event.key.action,
+          key: event.key,
+          pipelineId: event.pipelineId,
+          status: convertPreloadingStatus(event.status),
+          prerenderStatus: event.prerenderStatus || null,
+          disallowedMojoInterface: event.disallowedMojoInterface || null,
+          mismatchedHeaders: event.mismatchedHeaders || null,
+        };
+        break;
+      default:
+        throw new Error(`unreachable: event.key.action: ${event.key.action}`);
+    }
     this.documents.get(loaderId)?.preloadingAttempts.upsert(attempt);
     this.dispatchEventToListeners(Events.MODEL_UPDATED);
   }
@@ -458,7 +476,7 @@ function convertPreloadingStatus(status: Protocol.Preload.PreloadingStatus): Pre
 
 export type PreloadingAttemptId = string;
 
-export type PreloadingAttempt = PrefetchAttempt|PrerenderAttempt;
+export type PreloadingAttempt = PrefetchAttempt|PrerenderAttempt|PrerenderUntilScriptAttempt;
 
 export interface PrefetchAttempt {
   action: Protocol.Preload.SpeculationAction.Prefetch;
@@ -483,7 +501,20 @@ export interface PrerenderAttempt {
   nodeIds: Protocol.DOM.BackendNodeId[];
 }
 
-export type PreloadingAttemptInternal = PrefetchAttemptInternal|PrerenderAttemptInternal;
+export interface PrerenderUntilScriptAttempt {
+  action: Protocol.Preload.SpeculationAction.PrerenderUntilScript;
+  key: Protocol.Preload.PreloadingAttemptKey;
+  pipelineId: Protocol.Preload.PreloadPipelineId|null;
+  status: PreloadingStatus;
+  prerenderStatus: Protocol.Preload.PrerenderFinalStatus|null;
+  disallowedMojoInterface: string|null;
+  mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[]|null;
+  ruleSetIds: Protocol.Preload.RuleSetId[];
+  nodeIds: Protocol.DOM.BackendNodeId[];
+}
+
+export type PreloadingAttemptInternal =
+    PrefetchAttemptInternal|PrerenderAttemptInternal|PrerenderUntilScriptAttemptInternal;
 
 export interface PrefetchAttemptInternal {
   action: Protocol.Preload.SpeculationAction.Prefetch;
@@ -504,6 +535,16 @@ export interface PrerenderAttemptInternal {
   mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[]|null;
 }
 
+export interface PrerenderUntilScriptAttemptInternal {
+  action: Protocol.Preload.SpeculationAction.PrerenderUntilScript;
+  key: Protocol.Preload.PreloadingAttemptKey;
+  pipelineId: Protocol.Preload.PreloadPipelineId|null;
+  status: PreloadingStatus;
+  prerenderStatus: Protocol.Preload.PrerenderFinalStatus|null;
+  disallowedMojoInterface: string|null;
+  mismatchedHeaders: Protocol.Preload.PrerenderMismatchedHeaders[]|null;
+}
+
 function makePreloadingAttemptId(key: Protocol.Preload.PreloadingAttemptKey): PreloadingAttemptId {
   let action;
   switch (key.action) {
@@ -513,6 +554,9 @@ function makePreloadingAttemptId(key: Protocol.Preload.PreloadingAttemptKey): Pr
     case Protocol.Preload.SpeculationAction.Prerender:
       action = 'Prerender';
       break;
+    case Protocol.Preload.SpeculationAction.PrerenderUntilScript:
+      action = 'PrerenderUntilScript';
+      break;
   }
 
   let targetHint;
@@ -551,7 +595,7 @@ export class PreloadPipeline {
   }
 
   getOriginallyTriggered(): PreloadingAttempt {
-    const attempt = this.getPrerender() || this.getPrefetch();
+    const attempt = this.getPrerender() || this.getPrerenderUntilScript() || this.getPrefetch();
     assertNotNullOrUndefined(attempt);
     return attempt;
   }
@@ -564,7 +608,11 @@ export class PreloadPipeline {
     return this.inner.get(Protocol.Preload.SpeculationAction.Prerender) || null;
   }
 
-  // Returns attempts in the order: prefetch < prerender.
+  getPrerenderUntilScript(): PreloadingAttempt|null {
+    return this.inner.get(Protocol.Preload.SpeculationAction.PrerenderUntilScript) || null;
+  }
+
+  // Returns attempts in the order: prefetch < prerender_until_script < prerender.
   // Currently unused.
   getAttempts(): PreloadingAttempt[] {
     const ret = [];
@@ -579,6 +627,11 @@ export class PreloadPipeline {
       ret.push(prerender);
     }
 
+    const prerenderUntilScript = this.getPrerenderUntilScript();
+    if (prerenderUntilScript !== null) {
+      ret.push(prerenderUntilScript);
+    }
+
     if (ret.length === 0) {
       throw new Error('unreachable');
     }
@@ -615,7 +668,9 @@ class PreloadingAttemptRegistry {
   //
   // In some cases, browsers automatically triggers preloads. For example, Chrome triggers prefetch
   // ahead of prerender to prevent multiple fetches in case that the prerender failed due to, e.g.
-  // use of forbidden mojo APIs. Such prefetch and prerender sit in the same preload pipeline.
+  // use of forbidden mojo APIs. Also, a prerender-until-script attempt triggers prefetch as well,
+  // and can upgrade to prerender. Such prefetch, prerender-until-script, and prerender sit in the
+  // same preload pipeline.
   //
   // We regard them as not representative and only show the representative ones to represent
   // pipelines.
@@ -624,9 +679,9 @@ class PreloadingAttemptRegistry {
       switch (action) {
         case Protocol.Preload.SpeculationAction.Prefetch:
           return 0;
-        case Protocol.Preload.SpeculationAction.Prerender:
-          return 1;
         case Protocol.Preload.SpeculationAction.PrerenderUntilScript:
+          return 1;
+        case Protocol.Preload.SpeculationAction.Prerender:
           return 2;
       }
     }
@@ -738,7 +793,6 @@ class PreloadingAttemptRegistry {
           };
           break;
         case Protocol.Preload.SpeculationAction.Prerender:
-        case Protocol.Preload.SpeculationAction.PrerenderUntilScript:
           attempt = {
             action: Protocol.Preload.SpeculationAction.Prerender,
             key,
@@ -749,6 +803,17 @@ class PreloadingAttemptRegistry {
             mismatchedHeaders: null,
           };
           break;
+        case Protocol.Preload.SpeculationAction.PrerenderUntilScript:
+          attempt = {
+            action: Protocol.Preload.SpeculationAction.PrerenderUntilScript,
+            key,
+            pipelineId: null,
+            status: PreloadingStatus.NOT_TRIGGERED,
+            prerenderStatus: null,
+            disallowedMojoInterface: null,
+            mismatchedHeaders: null,
+          };
+          break;
       }
       this.map.set(id, attempt);
     }

package/front_end/core/sdk/RehydratingConnection.snapshot.txt

@@ -420,7 +420,7 @@ Content:
     "url": "https://www.paulirish.com/javascripts/firebase-performance-standalone.js",
     "hasSourceURL": false,
     "sourceURL": "",
-    "sourceMapURL": "firebase-performance-standalone.js.map",
+    "sourceMapURL": "data:application/json;charset=utf-8,%7B%22version%22%3A3%2C%22file%22%3A%22firebase-performance-standalone.js%22%2C%22sources%22%3A%5B%22..%2F..%2Fnode_modules%2Ftslib%2Ftslib.es6.js%22%2C%22..%2Futil…",
     "pid": 97964,
     "sourceText": "!function(e,t){\"obje…",
     "length": 48248,

package/front_end/core/sdk/RehydratingConnection.ts

@@ -28,6 +28,7 @@ import * as Common from '../common/common.js';
 import * as i18n from '../i18n/i18n.js';
 import type * as Platform from '../platform/platform.js';
 import type * as ProtocolClient from '../protocol_client/protocol_client.js';
+import * as Root from '../root/root.js';
 
 import * as EnhancedTraces from './EnhancedTracesParser.js';
 import type {
@@ -69,14 +70,38 @@ export class RehydratingConnection implements ProtocolClient.InspectorBackend.Co
   trace: TraceObject|null = null;
   sessions = new Map<number, RehydratingSessionBase>();
   #onConnectionLost: (message: Platform.UIString.LocalizedString) => void;
-  #rehydratingWindow: Window&typeof globalThis;
+  #rehydratingWindow = window;
   #onReceiveHostWindowPayloadBound = this.onReceiveHostWindowPayload.bind(this);
 
   constructor(onConnectionLost: (message: Platform.UIString.LocalizedString) => void) {
-    // If we're invoking this class, we're in the rehydrating pop-up window. Rename window for clarity.
     this.#onConnectionLost = onConnectionLost;
-    this.#rehydratingWindow = window;
-    this.#setupMessagePassing();
+    if (!this.#maybeHandleLoadingFromUrl()) {
+      this.#setupMessagePassing();
+    }
+  }
+
+  /** Returns true if found a trace URL. */
+  #maybeHandleLoadingFromUrl(): boolean {
+    let traceUrl = Root.Runtime.Runtime.queryParam('traceURL');
+
+    if (!traceUrl) {
+      // For compatibility, handle the older loadTimelineFromURL.
+      const timelineUrl = Root.Runtime.Runtime.queryParam('loadTimelineFromURL');
+      if (timelineUrl) {
+        // It was double-URI encoded for some reason.
+        traceUrl = decodeURIComponent(timelineUrl);
+      }
+    }
+
+    if (traceUrl) {
+      void fetch(traceUrl).then(r => r.arrayBuffer()).then(b => Common.Gzip.arrayBufferToString(b)).then(traceJson => {
+        const trace = new TraceObject(JSON.parse(traceJson));
+        void this.startHydration(trace);
+      });
+      return true;
+    }
+
+    return false;
   }
 
   #setupMessagePassing(): void {

package/front_end/core/sdk/ScopeTreeCache.ts

@@ -8,19 +8,23 @@ import * as TextUtils from '../../models/text_utils/text_utils.js';
 import type {Script} from './Script.js';
 
 type ScopeTreeNode = Formatter.FormatterWorkerPool.ScopeTreeNode;
+type Text = TextUtils.Text.Text;
 
 /** If a script failed to parse, we stash null in order to prevent unnecessary re-parsing */
-const scopeTrees = new WeakMap<Script, Promise<ScopeTreeNode|null>>();
+const scopeTrees = new WeakMap<Script, Promise<{scopeTree: ScopeTreeNode, text: Text}|null>>();
 
 /**
  * Computes and caches the scope tree for `script`.
  *
  * We use {@link Script} as a key to uniquely identify scripts.
  * {@link Script} boils down to "target" + "script ID". This
- * duplicates work in case of identitical script running on multiple targets
+ * duplicates work in case of identical script running on multiple targets
  * (e.g. workers).
+ *
+ * We also return a {@link TextUtils.Text.Text} instance. The scope tree uses offsets
+ * and the text allows conversion from/to line/column numbers.
  */
-export function scopeTreeForScript(script: Script): Promise<ScopeTreeNode|null> {
+export function scopeTreeForScript(script: Script): Promise<{scopeTree: ScopeTreeNode, text: Text}|null> {
   let promise = scopeTrees.get(script);
   if (promise === undefined) {
     promise = script.requestContentData().then(content => {
@@ -31,6 +35,7 @@ export function scopeTreeForScript(script: Script): Promise<ScopeTreeNode|null>
       const sourceType = script.isModule ? 'module' : 'script';
       return Formatter.FormatterWorkerPool.formatterWorkerPool()
           .javaScriptScopeTree(content.text, sourceType)
+          .then(scopeTree => scopeTree ? ({scopeTree, text: content.textObj}) : null)
           .catch(() => null);
     });
     scopeTrees.set(script, promise);