chrome-devtools-frontend 1.0.1690531 → 1.0.1695017

package/front_end/core/sdk/ResourceTreeModel.ts

@@ -15,6 +15,7 @@ import type {NetworkRequest} from './NetworkRequest.js';
 import {Resource} from './Resource.js';
 import {ExecutionContext, RuntimeModel} from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';
+import {SecurityOrigin} from './SecurityOrigin.js';
 import {SecurityOriginManager} from './SecurityOriginManager.js';
 import {StorageKeyManager} from './StorageKeyManager.js';
 import {Capability, type Target, Type} from './Target.js';
@@ -82,6 +83,37 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
     return result;
   }
 
+  /**
+   * Finds the first active frame that matches the specified security origin under
+   * the given primary page target.
+   *
+   * Returns `null` if the target has no outermost target or if no matching frame
+   * exists.
+   *
+   * @param primaryPageTarget The primary page target that contains the candidate frames.
+   * @param origin The security origin to match.
+   * @returns The first matching frame, or `null` if no frame matches.
+   */
+  static frameForOrigin(
+      primaryPageTarget: Target,
+      origin: SecurityOrigin,
+      ): ResourceTreeFrame|null {
+    const outermostTarget = primaryPageTarget.outermostTarget();
+    if (!outermostTarget) {
+      return null;
+    }
+    for (const frame of ResourceTreeModel.frames(primaryPageTarget.targetManager())) {
+      if (frame.resourceTreeModel().target().outermostTarget() !== outermostTarget) {
+        continue;
+      }
+      if (frame.securityOrigin().isSameOriginWith(origin)) {
+        return frame;
+      }
+    }
+
+    return null;
+  }
+
   static resourceForURL(targetManager: TargetManager, url: Platform.DevToolsPath.UrlString): Resource|null {
     for (const resourceTreeModel of targetManager.models(ResourceTreeModel)) {
       const mainFrame = resourceTreeModel.mainFrame;
@@ -500,24 +532,26 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
   }
 
   private getSecurityOriginData(): SecurityOriginData {
-    const securityOrigins = new Set<string>();
+    const securityOrigins: SecurityOrigin[] = [];
 
-    let mainSecurityOrigin: string|null = null;
-    let unreachableMainSecurityOrigin: string|null = null;
+    let mainSecurityOrigin: SecurityOrigin|null = null;
+    let unreachableMainSecurityOrigin: SecurityOrigin|null = null;
     for (const frame of this.framesInternal.values()) {
-      const origin = frame.securityOrigin;
-      if (!origin) {
-        continue;
-      }
-
-      securityOrigins.add(origin);
+      const origin = frame.securityOrigin();
       if (frame.isMainFrame()) {
-        mainSecurityOrigin = origin;
+        mainSecurityOrigin = origin.isOpaque() ? null : origin;
         if (frame.unreachableUrl()) {
-          const unreachableParsed = new Common.ParsedURL.ParsedURL(frame.unreachableUrl());
-          unreachableMainSecurityOrigin = unreachableParsed.securityOrigin();
+          const unreachable = SecurityOrigin.create(frame.unreachableUrl());
+          unreachableMainSecurityOrigin = unreachable.isOpaque() ? null : unreachable;
         }
       }
+      if (origin.isOpaque()) {
+        continue;
+      }
+
+      if (!securityOrigins.some(existing => existing.isSameOriginWith(origin))) {
+        securityOrigins.push(origin);
+      }
     }
     return {
       securityOrigins,
@@ -548,9 +582,12 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
 
   private updateSecurityOrigins(): void {
     const data = this.getSecurityOriginData();
-    this.#securityOriginManager.setMainSecurityOrigin(
-        data.mainSecurityOrigin || '', data.unreachableMainSecurityOrigin || '');
-    this.#securityOriginManager.updateSecurityOrigins(data.securityOrigins);
+    // TODO(crbug.com/559122726): SecurityOriginManager currently expects string identifiers.
+    // Update SecurityOriginManager to store and emit SecurityOrigin objects directly so
+    // that the siteId() conversions below can be removed.
+    this.#securityOriginManager.setMainSecurityOrigin(data.mainSecurityOrigin?.siteId() || '',
+                                                      data.unreachableMainSecurityOrigin?.siteId() || '');
+    this.#securityOriginManager.updateSecurityOrigins(new Set(data.securityOrigins.map(o => o.siteId())));
   }
 
   private async updateStorageKeys(): Promise<void> {
@@ -563,9 +600,10 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
     return this.mainFrame ? await this.mainFrame.getStorageKey(/* forceFetch */ false) : null;
   }
 
+  // TODO(crbug.com/559122726): Remove siteId() usage and evaluate removing this method in favor of direct SecurityOrigin handling.
   getMainSecurityOrigin(): string|null {
     const data = this.getSecurityOriginData();
-    return data.mainSecurityOrigin || data.unreachableMainSecurityOrigin;
+    return data.mainSecurityOrigin?.siteId() || data.unreachableMainSecurityOrigin?.siteId() || null;
   }
 
   onBackForwardCacheNotUsed(event: Protocol.Page.BackForwardCacheNotUsedEvent): void {
@@ -649,7 +687,7 @@ export class ResourceTreeFrame {
   #name: string|null|undefined;
   #url: Platform.DevToolsPath.UrlString;
   #domainAndRegistry: string;
-  #securityOrigin: string|null;
+  #securityOrigin: SecurityOrigin;
   #securityOriginDetails?: Protocol.Page.SecurityOriginDetails;
   #storageKey?: Promise<string|null>;
   #unreachableUrl: Platform.DevToolsPath.UrlString;
@@ -680,7 +718,7 @@ export class ResourceTreeFrame {
     this.#name = payload?.name;
     this.#url = payload && payload.url as Platform.DevToolsPath.UrlString || Platform.DevToolsPath.EmptyUrlString;
     this.#domainAndRegistry = (payload?.domainAndRegistry) || '';
-    this.#securityOrigin = payload?.securityOrigin ?? null;
+    this.#securityOrigin = SecurityOrigin.create(payload?.securityOrigin ?? '');
     this.#securityOriginDetails = payload?.securityOriginDetails;
     this.#unreachableUrl =
         (payload && payload.unreachableUrl as Platform.DevToolsPath.UrlString) || Platform.DevToolsPath.EmptyUrlString;
@@ -729,7 +767,7 @@ export class ResourceTreeFrame {
     this.#name = framePayload.name;
     this.#url = framePayload.url as Platform.DevToolsPath.UrlString;
     this.#domainAndRegistry = framePayload.domainAndRegistry;
-    this.#securityOrigin = framePayload.securityOrigin;
+    this.#securityOrigin = SecurityOrigin.create(framePayload.securityOrigin);
     this.#securityOriginDetails = framePayload.securityOriginDetails;
     void this.getStorageKey(/* forceFetch */ true);
     this.#unreachableUrl =
@@ -779,7 +817,15 @@ export class ResourceTreeFrame {
     return res.adScriptAncestry || null;
   }
 
-  get securityOrigin(): string|null {
+  /**
+   * Returns the security origin of this frame.
+   *
+   * If the frame does not have a valid origin (such as `about:blank`), this
+   * method returns a unique opaque origin.
+   *
+   * @returns The security origin of the frame.
+   */
+  securityOrigin(): SecurityOrigin {
     return this.#securityOrigin;
   }
 
@@ -1165,10 +1211,13 @@ export class PageDispatcher implements ProtocolProxyApi.PageDispatcher {
 }
 
 SDKModel.register(ResourceTreeModel, {capabilities: Capability.DOM, autostart: true, early: true});
+/**
+ * Aggregated security origin data for frames belonging to a resource tree model.
+ */
 export interface SecurityOriginData {
-  securityOrigins: Set<string>;
-  mainSecurityOrigin: string|null;
-  unreachableMainSecurityOrigin: string|null;
+  securityOrigins: SecurityOrigin[];
+  mainSecurityOrigin: SecurityOrigin|null;
+  unreachableMainSecurityOrigin: SecurityOrigin|null;
 }
 
 export interface StorageKeyData {

package/front_end/core/sdk/SecurityOrigin.ts

@@ -7,11 +7,12 @@ import type * as Platform from '../platform/platform.js';
 
 /**
  * Internal representation of a security origin:
- * - `origin`: A comparable origin string (`<scheme>://<host>[:<port>]` or path-scoped `file://<host>/<path>`).
+ * - `origin`: A comparable origin string (`<scheme>://<host>[:<port>]`).
+ * - `file`: A path-scoped local file origin (`file://<host>/<path>`).
  * - `opaque`: An isolated opaque origin uniquely identified by a UUID that never matches any other origin.
  */
-type InternalOrigin =
-    |{readonly type: 'origin', readonly value: string}|{readonly type: 'opaque', readonly uuid: string};
+type InternalOrigin =|{readonly type: 'origin', readonly value: string}|{readonly type: 'file', readonly value: string}|
+    {readonly type: 'opaque', readonly uuid: string};
 
 /** Exact string matches that represent an invalid or opaque origin. */
 const OPAQUE_EXACT_MATCHES = new Set([
@@ -31,12 +32,14 @@ const OPAQUE_PREFIXES = [
 ] as const;
 
 /**
- * String prefixes for imported artifact schemes (e.g., HAR recordings, traces).
- * Imported entities operate in an isolated origin domain (`imported-har://${domain}`)
- * that never matches live web origins (`https://${domain}`).
+ * Scheme prefixes for imported artifact data (such as HAR archives and performance traces).
+ * DevTools isolates imported artifacts into scheme-scoped and host-scoped origins
+ * (`imported-har://${host}`, `imported-trace://${host}`). These origins never match live
+ * web origins (`https://${host}`) or other artifact schemes.
  */
 export const IMPORTED_ORIGIN_PREFIXES: ReadonlySet<string> = new Set([
   'imported-har:',
+  'imported-trace:',
 ]);
 
 function isOpaqueUrlString(url: string): boolean {
@@ -69,7 +72,12 @@ function isOpaqueUrlString(url: string): boolean {
  *    `isOpaque()` returns `false` for `file://` URLs, and two `file://` URLs are considered same-origin
  *    only if their full file path and host match exactly.
  *
- * 3. **Opaque Origins**: Opaque contexts (`data:`, `about:blank`, invalid URLs, or synthetic
+ * 3. **Imported Artifact Origins (`imported-har:`, `imported-trace:`)**: Custom schemes for imported
+ *    recordings (such as HAR archives and performance traces) resolve to `<scheme>//<host>`.
+ *    DevTools isolates imported artifact origins from live web pages (`imported-trace://example.com` != `https://example.com`)
+ *    and isolates different artifact schemes from each other (`imported-trace://example.com` != `imported-har://example.com`).
+ *
+ * 4. **Opaque Origins**: Opaque contexts (`data:`, `about:blank`, invalid URLs, or synthetic
  *    opaque origins) are backed by unique UUIDs. An opaque origin never matches any other origin,
  *    even another opaque origin created from the same URL string.
  */
@@ -85,6 +93,8 @@ export class SecurityOrigin {
    *
    * - If the URL is determined to be opaque (e.g. `data:`, `about:blank`, empty, `null`),
    *   a new unique opaque origin is returned.
+   * - If the URL is an imported artifact scheme (e.g. `imported-har:`, `imported-trace:`),
+   *   a scheme-and-host origin (`<scheme>//<host>`) is returned.
    * - If the URL is a `file://` URL, a path-scoped origin (`file://<authority><path>`) is returned.
    * - Otherwise, the standard origin (`<scheme>://<host>[:<port>]`) is extracted and returned.
    *
@@ -95,20 +105,9 @@ export class SecurityOrigin {
       return SecurityOrigin.createUniqueOpaque();
     }
 
-    // Custom imported schemes (e.g. `imported-har:`) are not supported by standard URL parsers.
-    // We extract the host to construct a domain-scoped origin (`imported-har://${host}`).
-    // This isolates imported artifacts from live web pages (`imported-har://example.com` != `https://example.com`),
-    // while enabling same-origin comparison between requests within the same imported session domain.
-    for (const prefix of IMPORTED_ORIGIN_PREFIXES) {
-      if (rawUrl.toLowerCase().startsWith(prefix)) {
-        const afterScheme = rawUrl.substring(prefix.length).replace(/^\/+/, '');
-        const slashIndex = afterScheme.indexOf('/');
-        const host = slashIndex === -1 ? afterScheme : afterScheme.substring(0, slashIndex);
-        if (!host) {
-          return SecurityOrigin.createUniqueOpaque();
-        }
-        return new SecurityOrigin({type: 'origin', value: `${prefix}//${host.toLowerCase()}`});
-      }
+    const importedOrigin = SecurityOrigin.#tryCreateImportedArtifactOrigin(rawUrl);
+    if (importedOrigin) {
+      return importedOrigin;
     }
 
     if (rawUrl.toLowerCase().startsWith('file://')) {
@@ -117,7 +116,7 @@ export class SecurityOrigin {
         return SecurityOrigin.createUniqueOpaque();
       }
       const authority = parsed.host + (parsed.port ? ':' + parsed.port : '');
-      return new SecurityOrigin({type: 'origin', value: `file://${authority}${parsed.path}`});
+      return new SecurityOrigin({type: 'file', value: `file://${authority}${parsed.path}`});
     }
 
     const origin = Common.ParsedURL.ParsedURL.extractOrigin(rawUrl as Platform.DevToolsPath.UrlString);
@@ -125,7 +124,35 @@ export class SecurityOrigin {
       return SecurityOrigin.createUniqueOpaque();
     }
 
-    return new SecurityOrigin({type: 'origin', value: origin});
+    return new SecurityOrigin({type: 'origin', value: origin.toLowerCase()});
+  }
+
+  /**
+   * Attempts to parse a URL as an imported artifact scheme (such as `imported-har:` or `imported-trace:`).
+   *
+   * Standard web origins do not match imported artifact origins. If the URL starts with an imported
+   * prefix, this helper isolates the origin to `<scheme>//<host>`. If the authority or host is missing,
+   * or if the URL cannot be parsed, it returns a unique opaque origin.
+   *
+   * @param rawUrl The raw URL string to evaluate.
+   * @returns A `SecurityOrigin` if the URL matches an imported artifact scheme, or `null` otherwise.
+   */
+  static #tryCreateImportedArtifactOrigin(rawUrl: string): SecurityOrigin|null {
+    const lowerUrl = rawUrl.toLowerCase();
+    for (const prefix of IMPORTED_ORIGIN_PREFIXES) {
+      if (lowerUrl.startsWith(prefix)) {
+        try {
+          const parsedUrl = new URL(rawUrl);
+          if (!parsedUrl.host) {
+            return SecurityOrigin.createUniqueOpaque();
+          }
+          return new SecurityOrigin({type: 'origin', value: `${parsedUrl.protocol}//${parsedUrl.host.toLowerCase()}`});
+        } catch {
+          return SecurityOrigin.createUniqueOpaque();
+        }
+      }
+    }
+    return null;
   }
 
   /**
@@ -138,6 +165,28 @@ export class SecurityOrigin {
     return new SecurityOrigin({type: 'opaque', uuid: crypto.randomUUID()});
   }
 
+  /**
+   * Creates an isolated security origin for an imported performance trace.
+   *
+   * Imported traces isolate to `imported-trace://${authority}` based on the recorded
+   * main frame URL. If the URL is missing, invalid, or has no host, this returns a
+   * unique opaque origin so that unhosted traces do not share access with each other
+   * or live web origins.
+   *
+   * @param mainFrameURL The URL string of the main frame recorded in the trace.
+   */
+  static createForImportedTrace(mainFrameURL: string|null|undefined): SecurityOrigin {
+    if (!mainFrameURL) {
+      return SecurityOrigin.createUniqueOpaque();
+    }
+    const parsed = Common.ParsedURL.ParsedURL.fromString(mainFrameURL);
+    if (!parsed?.host) {
+      return SecurityOrigin.createUniqueOpaque();
+    }
+    const authority = parsed.host + (parsed.port ? `:${parsed.port}` : '');
+    return SecurityOrigin.create(`imported-trace://${authority}`);
+  }
+
   /**
    * Checks whether this security origin is equivalent to another security origin.
    *
@@ -156,7 +205,7 @@ export class SecurityOrigin {
       return this.#origin.type === 'opaque' && other.#origin.type === 'opaque' &&
           this.#origin.uuid === other.#origin.uuid;
     }
-    return this.#origin.value === other.#origin.value;
+    return this.#origin.type === other.#origin.type && this.#origin.value === other.#origin.value;
   }
 
   /**
@@ -170,12 +219,23 @@ export class SecurityOrigin {
   }
 
   /**
-   * Returns a stable string representation of this origin for identification, storage keys,
-   * or debugging logs.
+   * Returns whether this origin represents a local file origin (`file://`).
+   */
+  isFile(): boolean {
+    return this.#origin.type === 'file';
+  }
+
+  /**
+   * Returns a stable string identifier for display, logging, or storage keys.
+   *
+   * WARNING: Do not compare `siteId()` strings to verify origin equality or
+   * enforce security boundaries. Always use `isSameOriginWith()` instead.
    *
-   * - For standard origins, returns the serialized origin string (e.g. `https://example.com:8080`).
-   * - For file origins, returns the path-scoped origin (e.g. `file:///path/to/file.html`).
-   * - For opaque origins, returns the unique UUID string.
+   * Return formats:
+   * - Standard origins: `<scheme>://<host>[:<port>]` (e.g., `https://example.com:8080`).
+   * - File origins: `file://<authority><path>` (e.g., `file:///path/to/file.html`).
+   * - Opaque origins: A bare UUID string (e.g., `3fa85f64-5717-4562-b3fc-2c963f66afa6`).
+   *   Note: Opaque site IDs do not have URI schemes and are not valid URLs.
    */
   siteId(): string {
     return this.#origin.type === 'opaque' ? this.#origin.uuid : this.#origin.value;

package/front_end/core/sdk/Target.ts

@@ -8,6 +8,7 @@ import * as Platform from '../platform/platform.js';
 import * as ProtocolClient from '../protocol_client/protocol_client.js';
 
 import {SDKModel, type SDKModelConstructor} from './SDKModel.js';
+import {SecurityOrigin} from './SecurityOrigin.js';
 import type {TargetManager} from './TargetManager.js';
 
 export class Target extends ProtocolClient.InspectorBackend.TargetBase {
@@ -15,6 +16,8 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
   #name: string;
   #inspectedURL: Platform.DevToolsPath.UrlString = Platform.DevToolsPath.EmptyUrlString;
   #inspectedURLName = '';
+  /** Caches the parsed security origin for `#inspectedURL`. */
+  #inspectedSecurityOrigin: SecurityOrigin|null = null;
   readonly #capabilitiesMask: number;
   #type: Type;
   readonly #parentTarget: Target|null;
@@ -206,8 +209,23 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
     return this.#inspectedURL;
   }
 
+  /**
+   * Returns the security origin for this target's inspected URL.
+   *
+   * The target caches the origin until `setInspectedURL()` changes the URL.
+   * If the URL is empty or invalid, this method returns a unique opaque origin.
+   * An opaque origin does not match any other origin.
+   */
+  inspectedSecurityOrigin(): SecurityOrigin {
+    if (!this.#inspectedSecurityOrigin) {
+      this.#inspectedSecurityOrigin = SecurityOrigin.create(this.#inspectedURL);
+    }
+    return this.#inspectedSecurityOrigin;
+  }
+
   setInspectedURL(inspectedURL: Platform.DevToolsPath.UrlString): void {
     this.#inspectedURL = inspectedURL;
+    this.#inspectedSecurityOrigin = null;
     const parsedURL = Common.ParsedURL.ParsedURL.fromString(inspectedURL);
     this.#inspectedURLName = parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + this.#id;
     this.#targetManager.onInspectedURLChange(this);

package/front_end/core/sdk/sdk.ts

@@ -26,6 +26,7 @@ import * as CrashReportContextModel from './CrashReportContextModel.js';
 import * as CSSContainerQuery from './CSSContainerQuery.js';
 import * as CSSFontFace from './CSSFontFace.js';
 import * as CSSLayer from './CSSLayer.js';
+import * as CSSLocation from './CSSLocation.js';
 import * as CSSMatchedStyles from './CSSMatchedStyles.js';
 import * as CSSMedia from './CSSMedia.js';
 import * as CSSMetadata from './CSSMetadata.js';
@@ -115,6 +116,7 @@ export {
   CSSContainerQuery,
   CSSFontFace,
   CSSLayer,
+  CSSLocation,
   CSSMatchedStyles,
   CSSMedia,
   CSSMetadata,

package/front_end/entrypoints/main/MainImpl.ts

@@ -214,6 +214,8 @@ export class MainImpl {
     };
     this.#universe = new Foundation.Universe.Universe(creationOptions);
     Root.DevToolsContext.setGlobalInstance(this.#universe.context as Root.DevToolsContext.WritableDevToolsContext);
+    // Needed to allow CD4A to access the server bridge class.
+    (globalThis as unknown as {universe: Foundation.Universe.Universe}).universe = this.#universe;
 
     // Mark 'cache-disabled' as requiring user interaction when multiple CDP clients are attached.
     if (Root.Runtime.Runtime.queryParam('hasOtherClients')) {
@@ -552,6 +554,7 @@ export class MainImpl {
           inspectorView.displaySelectOverrideFolderInfobar(event.data);
         });
     await inspectorView.createToolbars();
+    inspectorView.renderStatusBar();
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.loadCompleted();
 
     // Initialize elements for the live announcer functionality for a11y.
@@ -669,7 +672,7 @@ export class MainImpl {
   }
 
   #redispatchClipboardEvent(event: Event): void {
-    const eventCopy = new CustomEvent('clipboard-' + event.type, {bubbles: true});
+    const eventCopy = new CustomEvent('clipboard-' + event.type, {bubbles: true, composed: true});
     // @ts-expect-error Used in ElementsTreeOutline
     eventCopy['original'] = event;
     const document = event.target && (event.target as HTMLElement).ownerDocument;
@@ -702,6 +705,10 @@ export class MainImpl {
     UI.InspectorView.InspectorView.instance().onSuspendStateChanged(suspended);
   }
 
+  redispatchClipboardEventForTest(event: Event): void {
+    this.#redispatchClipboardEvent(event);
+  }
+
   static instanceForTest: MainImpl|null = null;
 }
 

package/front_end/foundation/Universe.ts

@@ -38,6 +38,7 @@ export class Universe {
   //                            directly on the `Universe`.
   readonly context: Root.DevToolsContext.DevToolsContext;
   readonly autofillManager: AutofillManager.AutofillManager.AutofillManager;
+  readonly cd4aBridge: CommentManager.CD4ABridge.CD4ABridge|null = null;
   readonly supportsEmulation: boolean;
   readonly initAutomaticFilesystem: boolean;
   readonly fileSystemWorkspaceBinding: Persistence.FileSystemWorkspaceBinding.FileSystemWorkspaceBinding;
@@ -81,17 +82,11 @@ export class Universe {
     const multitargetNetworkManager = new SDK.NetworkManager.MultitargetNetworkManager(targetManager);
     context.set(SDK.NetworkManager.MultitargetNetworkManager, multitargetNetworkManager);
 
-    const workspace = new Workspace.Workspace.WorkspaceImpl();
-    context.set(Workspace.Workspace.WorkspaceImpl, workspace);
-
-    const fileManager = new Workspace.FileManager.FileManager();
-    context.set(Workspace.FileManager.FileManager, fileManager);
-
     this.supportsEmulation = options.supportsEmulation;
     let deviceModeModel = null;
     if (options.supportsEmulation) {
-      deviceModeModel = new Emulation.DeviceModeModel.DeviceModeModel(targetManager, settings,
-                                                                      multitargetNetworkManager, fileManager);
+      deviceModeModel =
+          new Emulation.DeviceModeModel.DeviceModeModel(targetManager, settings, multitargetNetworkManager);
       context.set(Emulation.DeviceModeModel.DeviceModeModel, deviceModeModel);
     }
 
@@ -130,6 +125,11 @@ export class Universe {
 
     const domModelUndoStack = new SDK.DOMModel.DOMModelUndoStack();
     context.set(SDK.DOMModel.DOMModelUndoStack, domModelUndoStack);
+    const workspace = new Workspace.Workspace.WorkspaceImpl();
+    context.set(Workspace.Workspace.WorkspaceImpl, workspace);
+
+    const fileManager = new Workspace.FileManager.FileManager();
+    context.set(Workspace.FileManager.FileManager, fileManager);
 
     if (automaticFileSystemManager) {
       const automaticFileSystemWorkspaceBinding =
@@ -215,7 +215,6 @@ export class Universe {
 
     const domIssuesManager = new IssuesManager.DOMIssuesManager.DOMIssuesManager(issuesManager, targetManager);
     context.set(IssuesManager.DOMIssuesManager.DOMIssuesManager, domIssuesManager);
-
     const javaScriptMetadata = new JavaScriptMetadata.JavaScriptMetadata.JavaScriptMetadataImpl();
     context.set(JavaScriptMetadata.JavaScriptMetadata.JavaScriptMetadataImpl, javaScriptMetadata);
 
@@ -234,6 +233,11 @@ export class Universe {
     const commentManager = new CommentManager.CommentManager.CommentManager();
     context.set(CommentManager.CommentManager.CommentManager, commentManager);
 
+    if (options.hostConfig.devToolsComments?.enabled ?? Root.Runtime.hostConfig.devToolsComments?.enabled) {
+      this.cd4aBridge = new CommentManager.CD4ABridge.CD4ABridge(commentManager, targetManager, networkLog);
+      context.set(CommentManager.CD4ABridge.CD4ABridge, this.cd4aBridge);
+    }
+
     this.autofillManager = new AutofillManager.AutofillManager.AutofillManager(targetManager, frameManager);
     context.set(AutofillManager.AutofillManager.AutofillManager, this.autofillManager);
   }
@@ -241,6 +245,7 @@ export class Universe {
   // TODO(crbug.com/542394587): Should be `Symbol.dispose`
   dispose(): void {
     // TODO(crbug.com/542394587): Track these in a DisposableStack.
+    this.cd4aBridge?.dispose();
     this.context.get(Persistence.IsolatedFileSystemManager.IsolatedFileSystemManager).dispose();
     if (this.initAutomaticFilesystem) {
       this.context.get(Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager).dispose();
@@ -273,7 +278,6 @@ export class Universe {
   get commentManager(): CommentManager.CommentManager.CommentManager {
     return this.context.get(CommentManager.CommentManager.CommentManager);
   }
-
   get cpuThrottlingManager(): SDK.CPUThrottlingManager.CPUThrottlingManager {
     return this.context.get(SDK.CPUThrottlingManager.CPUThrottlingManager);
   }
@@ -302,7 +306,6 @@ export class Universe {
   get domIssuesManager(): IssuesManager.DOMIssuesManager.DOMIssuesManager {
     return this.context.get(IssuesManager.DOMIssuesManager.DOMIssuesManager);
   }
-
   get domModelUndoStack(): SDK.DOMModel.DOMModelUndoStack {
     return this.context.get(SDK.DOMModel.DOMModelUndoStack);
   }

package/front_end/generated/Deprecation.ts

@@ -70,6 +70,10 @@ export const UIStrings = {
    * @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 Warning displayed to developers that they are using the Fenced Frame API which has been deprecated and is scheduled to be removed.
+   */
+  FencedFrame: "Fenced Frame API is deprecated and scheduled for removal.",
   /**
    * @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.
    */
@@ -349,6 +353,10 @@ export const DEPRECATIONS_METADATA: Partial<Record<string, DeprecationDescriptor
     "chromeStatusFeature": 5095987863486464,
     "milestone": 151
   },
+  "FencedFrame": {
+    "chromeStatusFeature": 6366274495053824,
+    "milestone": 156
+  },
   "IdentityInCanMakePaymentEvent": {
     "chromeStatusFeature": 5190978431352832
   },