chrome-devtools-frontend 1.0.1548980 → 1.0.1550444

package/front_end/core/sdk/PageResourceLoader.ts

@@ -7,8 +7,8 @@ import * as Common from '../common/common.js';
 import * as Host from '../host/host.js';
 import * as i18n from '../i18n/i18n.js';
 import type * as Platform from '../platform/platform.js';
+import * as Root from '../root/root.js';
 
-import {FrameManager} from './FrameManager.js';
 import {IOModel} from './IOModel.js';
 import {MultitargetNetworkManager, NetworkManager} from './NetworkManager.js';
 import {
@@ -68,7 +68,14 @@ export class ResourceKey {
   }
 }
 
-let pageResourceLoader: PageResourceLoader|null = null;
+export type UserAgentProvider = Pick<MultitargetNetworkManager, 'currentUserAgent'>;
+
+/**
+ * The PageResourceLoader has two responsibilities: loading resources and tracking statistics scoped to targets
+ * for the DeveloperResourcesPanel. Many places only require the former, so we expose that functionality via small
+ * sub-interface. This makes it easier to test classes that require resource loading.
+ */
+export type ResourceLoader = Pick<PageResourceLoader, 'loadResource'>;
 
 interface LoadQueueEntry {
   resolve: () => void;
@@ -80,7 +87,10 @@ interface LoadQueueEntry {
  * `PageResource` object around that holds meta information. This can be as the basis for reporting to the user which
  * resources were loaded, and whether there was a load error.
  */
-export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements ResourceLoader {
+  readonly #targetManager: TargetManager;
+  readonly #settings: Common.Settings.Settings;
+  readonly #userAgentProvider: UserAgentProvider;
   #currentlyLoading = 0;
   #currentlyLoadingPerTarget = new Map<Protocol.Target.TargetID|'main', number>();
   readonly #maxConcurrentLoads: number;
@@ -92,41 +102,51 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
                              errorDescription: Host.ResourceLoader.LoadErrorDescription,
                            }>)|null;
   constructor(
+      targetManager: TargetManager, settings: Common.Settings.Settings, userAgentProvider: UserAgentProvider,
       loadOverride: ((arg0: string) => Promise<{
                        success: boolean,
                        content: string,
                        errorDescription: Host.ResourceLoader.LoadErrorDescription,
                      }>)|null,
-      maxConcurrentLoads: number) {
+      maxConcurrentLoads = 500) {
     super();
+    this.#targetManager = targetManager;
+    this.#settings = settings;
+    this.#userAgentProvider = userAgentProvider;
     this.#maxConcurrentLoads = maxConcurrentLoads;
-    TargetManager.instance().addModelListener(
+    this.#targetManager.addModelListener(
         ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
     this.#loadOverride = loadOverride;
   }
 
-  static instance({forceNew, loadOverride, maxConcurrentLoads}: {
+  static instance({forceNew, targetManager, settings, userAgentProvider, loadOverride, maxConcurrentLoads}: {
     forceNew: boolean,
     loadOverride: (null|((arg0: string) => Promise<{
                            success: boolean,
                            content: string,
                            errorDescription: Host.ResourceLoader.LoadErrorDescription,
                          }>)),
-    maxConcurrentLoads: number,
+    targetManager?: TargetManager,
+    settings?: Common.Settings.Settings,
+    userAgentProvider?: UserAgentProvider,
+    maxConcurrentLoads?: number,
   } = {
     forceNew: false,
     loadOverride: null,
-    maxConcurrentLoads: 500,
   }): PageResourceLoader {
-    if (!pageResourceLoader || forceNew) {
-      pageResourceLoader = new PageResourceLoader(loadOverride, maxConcurrentLoads);
+    if (forceNew) {
+      Root.DevToolsContext.globalInstance().set(
+          PageResourceLoader,
+          new PageResourceLoader(
+              targetManager ?? TargetManager.instance(), settings ?? Common.Settings.Settings.instance(),
+              userAgentProvider ?? MultitargetNetworkManager.instance(), loadOverride, maxConcurrentLoads));
     }
 
-    return pageResourceLoader;
+    return Root.DevToolsContext.globalInstance().get(PageResourceLoader);
   }
 
   static removeInstance(): void {
-    pageResourceLoader = null;
+    Root.DevToolsContext.globalInstance().delete(PageResourceLoader);
   }
 
   onPrimaryPageChanged(
@@ -159,7 +179,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
 
   getScopedResourcesLoaded(): Map<string, PageResource> {
     return new Map([...this.#pageResources].filter(
-        ([_, pageResource]) => TargetManager.instance().isInScope(pageResource.initiator.target) ||
+        ([_, pageResource]) => this.#targetManager.isInScope(pageResource.initiator.target) ||
             isExtensionInitiator(pageResource.initiator)));
   }
 
@@ -180,11 +200,10 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     loading: number,
     resources: number,
   } {
-    const targetManager = TargetManager.instance();
     let loadingCount = 0;
     for (const [targetId, count] of this.#currentlyLoadingPerTarget) {
-      const target = targetManager.targetById(targetId);
-      if (targetManager.isInScope(target)) {
+      const target = this.#targetManager.targetById(targetId);
+      if (this.#targetManager.isInScope(target)) {
         loadingCount += count;
       }
     }
@@ -305,25 +324,15 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       return await this.#loadOverride(url);
     }
     const parsedURL = new Common.ParsedURL.ParsedURL(url);
-    const eligibleForLoadFromTarget = getLoadThroughTargetSetting().get() && parsedURL && parsedURL.scheme !== 'file' &&
-        parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools';
+    const eligibleForLoadFromTarget = this.getLoadThroughTargetSetting().get() && parsedURL &&
+        parsedURL.scheme !== 'file' && parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools' &&
+        initiator.target;
     Host.userMetrics.developerResourceScheme(this.getDeveloperResourceScheme(parsedURL));
     if (eligibleForLoadFromTarget) {
       try {
-        if (initiator.target) {
-          Host.userMetrics.developerResourceLoaded(
-              Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET);
-          const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
-          return result;
-        }
-        const frame = FrameManager.instance().getFrame(initiator.frameId);
-        if (frame) {
-          Host.userMetrics.developerResourceLoaded(
-              Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_FRAME);
-          const result =
-              await this.loadFromTarget(frame.resourceTreeModel().target(), initiator.frameId, url, isBinary);
-          return result;
-        }
+        Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET);
+        const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
+        return result;
       } catch (e) {
         if (e instanceof Error) {
           Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FAILURE);
@@ -339,13 +348,13 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       }
       Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FALLBACK);
     } else {
-      const code = getLoadThroughTargetSetting().get() ?
+      const code = this.getLoadThroughTargetSetting().get() ?
           Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_PROTOCOL :
           Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_OVERRIDE;
       Host.userMetrics.developerResourceLoaded(code);
     }
 
-    const result = await MultitargetNetworkManager.instance().loadResource(url);
+    const result = await this.loadFromHostBindings(url);
     if (eligibleForLoadFromTarget && !result.success) {
       Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_FAILURE);
     }
@@ -395,7 +404,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
   }> {
     const networkManager = (target.model(NetworkManager) as NetworkManager);
     const ioModel = (target.model(IOModel) as IOModel);
-    const disableCache = Common.Settings.Settings.instance().moduleSetting('cache-disabled').get();
+    const disableCache = this.#settings.moduleSetting('cache-disabled').get();
     const resource = await networkManager.loadNetworkResource(frameId, url, {disableCache, includeCredentials: true});
     try {
       const content = resource.stream ?
@@ -420,10 +429,34 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       }
     }
   }
-}
 
-export function getLoadThroughTargetSetting(): Common.Settings.Setting<boolean> {
-  return Common.Settings.Settings.instance().createSetting('load-through-target', true);
+  private async loadFromHostBindings(url: Platform.DevToolsPath.UrlString): Promise<{
+    success: boolean,
+    content: string,
+    errorDescription: Host.ResourceLoader.LoadErrorDescription,
+  }> {
+    const headers: Record<string, string> = {};
+
+    const currentUserAgent = this.#userAgentProvider.currentUserAgent();
+    if (currentUserAgent) {
+      headers['User-Agent'] = currentUserAgent;
+    }
+
+    if (this.#settings.moduleSetting('cache-disabled').get()) {
+      headers['Cache-Control'] = 'no-cache';
+    }
+
+    const allowRemoteFilePaths = this.#settings.moduleSetting('network.enable-remote-file-loading').get();
+
+    return await new Promise(
+        resolve => Host.ResourceLoader.load(url, headers, (success, _responseHeaders, content, errorDescription) => {
+          resolve({success, content, errorDescription});
+        }, allowRemoteFilePaths));
+  }
+
+  getLoadThroughTargetSetting(): Common.Settings.Setting<boolean> {
+    return this.#settings.createSetting('load-through-target', true);
+  }
 }
 
 export const enum Events {

package/front_end/core/sdk/SourceMap.ts

@@ -779,6 +779,12 @@ export class SourceMap {
     return this.#scopesInfo?.findOriginalFunctionName(position) ?? null;
   }
 
+  findOriginalFunctionScope(position: ScopesCodec.Position):
+      {scope: ScopesCodec.OriginalScope, url?: Platform.DevToolsPath.UrlString}|null {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo?.findOriginalFunctionScope(position) ?? null;
+  }
+
   isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
     this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.isOutlinedFrame(generatedLine, generatedColumn) ?? false;

package/front_end/core/sdk/SourceMapCache.ts

@@ -9,6 +9,11 @@ export class SourceMapCache {
   static readonly #INSTANCE = new SourceMapCache('devtools-source-map-cache');
 
   static instance(): SourceMapCache {
+    if (typeof window === 'undefined') {
+      // TODO(crbug.com/451502260): Move this behind a `HostRuntime` interface.
+      return IN_MEMORY_INSTANCE as unknown as
+          SourceMapCache;  // TS doesn't like that our in-memory class doesn't have the same private fields.
+    }
     return this.#INSTANCE;
   }
 
@@ -52,3 +57,19 @@ export class SourceMapCache {
     await window.caches.delete(this.#name);
   }
 }
+
+const IN_MEMORY_INSTANCE = new (class implements Pick<SourceMapCache, 'get'|'set'|'disposeForTest'> {
+  readonly #cache = new Map<DebugId, SourceMapV3>();
+
+  async set(debugId: DebugId, sourceMap: SourceMapV3): Promise<void> {
+    this.#cache.set(debugId, sourceMap);
+  }
+
+  async get(debugId: DebugId): Promise<SourceMapV3|null> {
+    return this.#cache.get(debugId) ?? null;
+  }
+
+  async disposeForTest(): Promise<void> {
+    // Do nothing.
+  }
+})();

package/front_end/core/sdk/SourceMapManager.ts

@@ -6,7 +6,7 @@ import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 
 import type {FrameAssociated} from './FrameAssociated.js';
-import {PageResourceLoader, type PageResourceLoadInitiator} from './PageResourceLoader.js';
+import {PageResourceLoader, type PageResourceLoadInitiator, type ResourceLoader} from './PageResourceLoader.js';
 import {type DebugId, parseSourceMap, SourceMap, type SourceMapV3} from './SourceMap.js';
 import {SourceMapCache} from './SourceMapCache.js';
 import {type Target, Type} from './Target.js';
@@ -112,8 +112,14 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
         if (this.#attachingClient === client) {
           this.#attachingClient = null;
           const initiator = client.createPageResourceLoadInitiator();
+          // TODO(crbug.com/458180550): Pass PageResourceLoader via constructor.
+          //     The reason we grab it here lazily from the context is that otherwise every
+          //     unit test using `createTarget` would need to set up a `PageResourceLoader`, as
+          //     CSSModel and DebuggerModel are autostarted by default, and they create a
+          //     SourceMapManager in their respective constructors.
+          const resourceLoader = this.#target.targetManager().context.get(PageResourceLoader);
           clientData.sourceMapPromise =
-              loadSourceMap(sourceMapURL, client.debugId(), initiator)
+              loadSourceMap(resourceLoader, sourceMapURL, client.debugId(), initiator)
                   .then(
                       payload => {
                         const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client);
@@ -180,8 +186,8 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
   }
 }
 
-export async function loadSourceMap(
-    url: Platform.DevToolsPath.UrlString, debugId: DebugId|null,
+async function loadSourceMap(
+    resourceLoader: ResourceLoader, url: Platform.DevToolsPath.UrlString, debugId: DebugId|null,
     initiator: PageResourceLoadInitiator): Promise<SourceMapV3> {
   try {
     if (debugId) {
@@ -191,7 +197,7 @@ export async function loadSourceMap(
       }
     }
 
-    const {content} = await PageResourceLoader.instance().loadResource(url, initiator);
+    const {content} = await resourceLoader.loadResource(url, initiator);
     const sourceMap = parseSourceMap(content);
     if ('debugId' in sourceMap && sourceMap.debugId) {
       // In case something goes wrong with updating the cache, we still want to use the source map.
@@ -204,9 +210,10 @@ export async function loadSourceMap(
 }
 
 export async function tryLoadSourceMap(
-    url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator): Promise<SourceMapV3|null> {
+    resourceLoader: ResourceLoader, url: Platform.DevToolsPath.UrlString,
+    initiator: PageResourceLoadInitiator): Promise<SourceMapV3|null> {
   try {
-    return await loadSourceMap(url, null, initiator);
+    return await loadSourceMap(resourceLoader, url, null, initiator);
   } catch (cause) {
     console.error(cause);
     return null;

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -121,14 +121,18 @@ export class SourceMapScopesInfo {
       const canMapOriginalPosition = startEntry && endEntry && sourceIndex !== undefined &&
           startEntry.sourceIndex === endEntry.sourceIndex && startEntry.sourceIndex !== undefined && sourceIndex >= 0 &&
           sourceIndex < numSourceUrls;
-      const isStackFrame = node.kind === Formatter.FormatterWorkerPool.ScopeKind.FUNCTION;
+      const isStackFrame = node.kind === Formatter.FormatterWorkerPool.ScopeKind.FUNCTION ||
+          node.kind === Formatter.FormatterWorkerPool.ScopeKind.ARROW_FUNCTION;
+      // TODO(crbug.com/368222773): Instead of mapping `start`, we should report a number of candidates. e.g. for arrow functions we should
+      //     follow the spec and map the `=>` as the spec says that is where the original name (if any) for arrow functions can be found.
+      const name = node.kind === Formatter.FormatterWorkerPool.ScopeKind.FUNCTION ? startEntry?.name : undefined;
 
       let scope: ScopesCodec.OriginalScope|undefined;
       if (canMapOriginalPosition) {
         scope = {
           start: {line: startEntry.sourceLineNumber, column: startEntry.sourceColumnNumber},
           end: {line: endEntry.sourceLineNumber, column: endEntry.sourceColumnNumber},
-          name: startEntry.name,
+          name,
           isStackFrame,
           variables: [],
           children: [],

package/front_end/core/sdk/TargetManager.ts

@@ -14,6 +14,16 @@ import {type RegistrationInfo, SDKModel, type SDKModelConstructor} from './SDKMo
 import {Target, Type as TargetType} from './Target.js';
 
 export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  /**
+   * @deprecated
+   *
+   * Intended for {@link SDKModel} classes to be able to retrieve scoped singletons like
+   * the "PageResourceLoader" or the "FrameManager".
+   *
+   * This is only an intermediate step to migrate towards our "layering vision" where
+   * SDKModels don't require things from the next layer.
+   */
+  readonly context: Root.DevToolsContext.DevToolsContext;
   #targets: Set<Target>;
   readonly #observers: Set<Observer>;
   /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -36,8 +46,9 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   /**
    * @param overrideAutoStartModels If provided, then the `autostart` flag on {@link RegistrationInfo} will be ignored.
    */
-  constructor(overrideAutoStartModels?: Set<SDKModelConstructor>) {
+  constructor(context: Root.DevToolsContext.DevToolsContext, overrideAutoStartModels?: Set<SDKModelConstructor>) {
     super();
+    this.context = context;
     this.#targets = new Set();
     this.#observers = new Set();
     this.#modelListeners = new Platform.MapUtilities.Multimap();
@@ -55,7 +66,8 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     forceNew: boolean,
   } = {forceNew: false}): TargetManager {
     if (!Root.DevToolsContext.globalInstance().has(TargetManager) || forceNew) {
-      Root.DevToolsContext.globalInstance().set(TargetManager, new TargetManager());
+      Root.DevToolsContext.globalInstance().set(
+          TargetManager, new TargetManager(Root.DevToolsContext.globalInstance()));
     }
 
     return Root.DevToolsContext.globalInstance().get(TargetManager);

package/front_end/core/sdk/sdk-meta.ts

@@ -387,6 +387,10 @@ const UIStrings = {
    * @description Title of a setting under the Sources category that can be invoked through the Command Menu
    */
   disableCssSourceMaps: 'Disable CSS source maps',
+  /**
+   * @description Title of a setting under the Console category in Settings
+   */
+  logXmlhttprequests: 'Log XMLHttpRequests',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('core/sdk/sdk-meta.ts', UIStrings);
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
@@ -1194,3 +1198,12 @@ Common.Settings.registerSettingExtension({
     },
   ],
 });
+
+Common.Settings.registerSettingExtension({
+  category: Common.Settings.SettingCategory.CONSOLE,
+  storageType: Common.Settings.SettingStorageType.SYNCED,
+  title: i18nLazyString(UIStrings.logXmlhttprequests),
+  settingName: 'monitoring-xhr-enabled',
+  settingType: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+});

package/front_end/entrypoints/formatter_worker/FormatterActions.ts

@@ -48,6 +48,7 @@ export const enum ScopeKind {
   BLOCK = 1,
   FUNCTION = 2,
   GLOBAL = 3,
+  ARROW_FUNCTION = 4,
 }
 
 export interface ScopeTreeNode {

package/front_end/entrypoints/formatter_worker/ScopeParser.ts

@@ -172,7 +172,7 @@ export class ScopeVariableAnalysis {
         node.elements.forEach(item => this.#processNode(item));
         break;
       case 'ArrowFunctionExpression': {
-        this.#pushScope(node.start, node.end, ScopeKind.FUNCTION);
+        this.#pushScope(node.start, node.end, ScopeKind.ARROW_FUNCTION);
         node.params.forEach(this.#processNodeAsDefinition.bind(this, DefinitionKind.VAR, false));
         if (node.body.type === 'BlockStatement') {
           // Include the body of the arrow function in the same scope as the arguments.

package/front_end/entrypoints/main/MainImpl.ts

@@ -132,6 +132,7 @@ let loadedPanelCommonModule: typeof PanelCommon|undefined;
 export class MainImpl {
   #readyForTestPromise = Promise.withResolvers<void>();
   #veStartPromise!: Promise<void>;
+  #universe!: Foundation.Universe.Universe;
 
   constructor() {
     MainImpl.instanceForTest = this;
@@ -175,8 +176,8 @@ export class MainImpl {
         runSettingsMigration: !Host.InspectorFrontendHost.isUnderTest(),
       },
     };
-    const universe = new Foundation.Universe.Universe(creationOptions);
-    Root.DevToolsContext.setGlobalInstance(universe.context);
+    this.#universe = new Foundation.Universe.Universe(creationOptions);
+    Root.DevToolsContext.setGlobalInstance(this.#universe.context);
 
     await this.requestAndRegisterLocaleData();
 
@@ -425,6 +426,7 @@ export class MainImpl {
         {forceNew: true, win: window, frontendHost: Host.InspectorFrontendHost.InspectorFrontendHostInstance});
     UI.ContextMenu.ContextMenu.initialize();
     UI.ContextMenu.ContextMenu.installHandler(document);
+    UI.ViewManager.ViewManager.instance({forceNew: true, universe: this.#universe});
 
     // These instances need to be created early so they don't miss any events about requests/issues/etc.
     Logs.NetworkLog.NetworkLog.instance();
@@ -439,7 +441,6 @@ export class MainImpl {
     IssuesManager.ContrastCheckTrigger.ContrastCheckTrigger.instance();
 
     UI.DockController.DockController.instance({forceNew: true, canDock});
-    SDK.NetworkManager.MultitargetNetworkManager.instance({forceNew: true});
     SDK.DOMDebuggerModel.DOMDebuggerManager.instance({forceNew: true});
     const targetManager = SDK.TargetManager.TargetManager.instance();
     targetManager.addEventListener(
@@ -939,7 +940,7 @@ export class MainMenuItem implements UI.Toolbar.Provider {
     contextMenu.appendItemsAtLocation('mainMenu');
     const moreTools =
         contextMenu.defaultSection().appendSubMenuItem(i18nString(UIStrings.moreTools), false, 'more-tools');
-    const viewExtensions = UI.ViewManager.getRegisteredViewExtensions();
+    const viewExtensions = UI.ViewManager.ViewManager.instance().getRegisteredViewExtensions();
     viewExtensions.sort((extension1, extension2) => {
       const title1 = extension1.title();
       const title2 = extension2.title();

package/front_end/foundation/Universe.ts

@@ -24,9 +24,16 @@ export class Universe {
       ...options.settingsCreationOptions,
     });
 
-    const targetManager = new SDK.TargetManager.TargetManager(options.overrideAutoStartModels);
+    const targetManager = new SDK.TargetManager.TargetManager(this.context, options.overrideAutoStartModels);
     this.context.set(SDK.TargetManager.TargetManager, targetManager);
 
+    const multitargetNetworkManager = new SDK.NetworkManager.MultitargetNetworkManager(targetManager);
+    this.context.set(SDK.NetworkManager.MultitargetNetworkManager, multitargetNetworkManager);
+
+    const pageResourceLoader =
+        new SDK.PageResourceLoader.PageResourceLoader(targetManager, settings, multitargetNetworkManager, null);
+    this.context.set(SDK.PageResourceLoader.PageResourceLoader, pageResourceLoader);
+
     const workspace = new Workspace.Workspace.WorkspaceImpl();
     this.context.set(Workspace.Workspace.WorkspaceImpl, workspace);
 

package/front_end/generated/Deprecation.ts

@@ -58,6 +58,10 @@ export const UIStrings = {
    * @description Warning displayed to developers when a data: URL is assigned to SVGUseElement to let them know that the support is deprecated.
    */
   DataUrlInSvgUse: "Support for data: URLs in SVGUseElement is deprecated and it will be removed in the future.",
+  /**
+   * @description Translation is not needed, this will never be exposed in production code.
+   */
+  ExampleBrowserProcessDeprecation: "This is an example for showing the code required for a browser process reported deprecation.",
   /**
    * @description A deprecation warning shown in the DevTools Issues tab. It's shown when one of the Protected Audience APIs like `navigator.joinAdInterestGroup`, `navigator.getInterestGroupAdAuctionData` or `navigator.runAdAuction` are called.
    */
@@ -174,10 +178,6 @@ export const UIStrings = {
    * @description Standard message when one web API is deprecated in favor of another.
    */
   PrefixedVideoSupportsFullscreen: "HTMLVideoElement.webkitSupportsFullscreen is deprecated. Please use Document.fullscreenEnabled instead.",
-  /**
-   * @description Warning displayed to developers that the API `chrome.privacy.websites.privacySandboxEnabled` is being deprecated in favour of three new more granular APIs: topicsEnabled, FledgeEnabled and adMeasurementEnabled. The `privacySandboxEnabled` API allowed extensions to control the homologous Chrome Setting. The existing Chrome Setting for Privacy Sandbox is also going away in favor of more granular settings that are matched by the new extensions APIs- topicsEnabled, FledgeEnabled and adMeasurementEnabled.
-   */
-  PrivacySandboxExtensionsAPI: "We're deprecating the API `chrome.privacy.websites.privacySandboxEnabled`, though it will remain active for backward compatibility until release M113. Instead, please use `chrome.privacy.websites.topicsEnabled`, `chrome.privacy.websites.fledgeEnabled` and `chrome.privacy.websites.adMeasurementEnabled`. See https://developer.chrome.com/docs/extensions/reference/privacy/#property-websites-privacySandboxEnabled.",
   /**
    * @description Standard message when one web API is deprecated in favor of another.
    */
@@ -210,6 +210,14 @@ export const UIStrings = {
    * @description A deprecation warning shown in the DevTools Issues tab. The placeholder is always the noun 'SharedArrayBuffer' which refers to a JavaScript construct.
    */
   SharedArrayBufferConstructedWithoutIsolation: "`SharedArrayBuffer` will require cross-origin isolation. See https://developer.chrome.com/blog/enabling-shared-array-buffer/ for more details.",
+  /**
+   * @description A deprecation warning shown in the DevTools Issues tab. It's shown when one of the Shared Storage APIs like `sharedStorage.set()`, `sharedStorage.worklet.addModule()`, `sharedStorage.selectURL()`, etc., along with `<img sharedstoragewritable>`, `<iframe sharedstoragewritable>`, or `fetch(url, {sharedStorageWritable: true})` are used.
+   */
+  SharedStorage: "The Shared Storage API is deprecated and will be removed in a future release.",
+  /**
+   * @description A deprecation warning shown in the DevTools Issues tab. It's shown when the `document.requestStorageAccessFor` API is called. The placeholder will always be the string `document.requestStorageAccessFor`.
+   */
+  StorageAccessAPI_requestStorageAccessFor_Method: "`document.requestStorageAccessFor` is deprecated and will be removed. See https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/ for more details.",
   /**
    * @description A deprecation warning shown in the DevTools Issues tab. It's shown when the speech synthesis API is called before the page receives a user activation.
    */
@@ -351,6 +359,12 @@ export const DEPRECATIONS_METADATA: Partial<Record<string, DeprecationDescriptor
   "SharedArrayBufferConstructedWithoutIsolation": {
     "milestone": 106
   },
+  "SharedStorage": {
+    "chromeStatusFeature": 5076349064708096
+  },
+  "StorageAccessAPI_requestStorageAccessFor_Method": {
+    "chromeStatusFeature": 5162221567082496
+  },
   "TextToSpeech_DisallowedByAutoplay": {
     "chromeStatusFeature": 5687444770914304,
     "milestone": 71