chrome-devtools-frontend 1.0.1674545 → 1.0.1676824

package/front_end/core/sdk/ResourceTreeModel.ts

@@ -247,6 +247,18 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
     }
   }
 
+  navigatedWithinDocument(frameId: Protocol.Page.FrameId, url: string): void {
+    const frame = this.framesInternal.get(frameId);
+    if (!frame) {
+      return;
+    }
+    frame.navigatedWithinDocument(url as Platform.DevToolsPath.UrlString);
+    if (frame.isMainFrame()) {
+      this.target().setInspectedURL(frame.url);
+    }
+    this.dispatchEventToListeners(Events.FrameNavigatedWithinDocument, frame);
+  }
+
   frameDetached(frameId: Protocol.Page.FrameId, isSwap: boolean): void {
     // Do nothing unless cached resource tree is processed - it will overwrite everything.
     if (!this.#cachedResourcesProcessed) {
@@ -584,6 +596,7 @@ export enum Events {
   /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
   FrameAdded = 'FrameAdded',
   FrameNavigated = 'FrameNavigated',
+  FrameNavigatedWithinDocument = 'FrameNavigatedWithinDocument',
   FrameDetached = 'FrameDetached',
   FrameResized = 'FrameResized',
   FrameWillNavigate = 'FrameWillNavigate',
@@ -607,6 +620,7 @@ export enum Events {
 export interface EventTypes {
   [Events.FrameAdded]: ResourceTreeFrame;
   [Events.FrameNavigated]: ResourceTreeFrame;
+  [Events.FrameNavigatedWithinDocument]: ResourceTreeFrame;
   [Events.FrameDetached]: {frame: ResourceTreeFrame, isSwap: boolean};
   [Events.FrameResized]: void;
   [Events.FrameWillNavigate]: ResourceTreeFrame;
@@ -736,6 +750,10 @@ export class ResourceTreeFrame {
     }
   }
 
+  navigatedWithinDocument(url: Platform.DevToolsPath.UrlString): void {
+    this.#url = url;
+  }
+
   resourceTreeModel(): ResourceTreeModel {
     return this.#model;
   }
@@ -1096,7 +1114,8 @@ export class PageDispatcher implements ProtocolProxyApi.PageDispatcher {
   frameStartedNavigating({}: Protocol.Page.FrameStartedNavigatingEvent): void {
   }
 
-  navigatedWithinDocument({}: Protocol.Page.NavigatedWithinDocumentEvent): void {
+  navigatedWithinDocument({frameId, url}: Protocol.Page.NavigatedWithinDocumentEvent): void {
+    this.#resourceTreeModel.navigatedWithinDocument(frameId, url);
   }
 
   frameResized(): void {

package/front_end/core/sdk/Script.ts

@@ -36,7 +36,6 @@ import * as TextUtils from '../text_utils/text_utils.js';
 import {
   COND_BREAKPOINT_SOURCE_URL,
   type DebuggerModel,
-  Events,
   Location,
   LOGPOINT_SOURCE_URL,
 } from './DebuggerModel.js';
@@ -80,7 +79,6 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
   executionContextId: number;
   hash: string;
   readonly #isContentScript: boolean;
-  readonly #isLiveEdit: boolean;
   sourceMapURL?: string;
   debugSymbols: Protocol.Debugger.DebugSymbols|null;
   hasSourceURL: boolean;
@@ -92,13 +90,13 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
   readonly #embedderName: Platform.DevToolsPath.UrlString|null;
   readonly isModule: boolean|null;
   readonly buildId: string|null;
-  constructor(
-      debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId, sourceURL: Platform.DevToolsPath.UrlString,
-      startLine: number, startColumn: number, endLine: number, endColumn: number, executionContextId: number,
-      hash: string, isContentScript: boolean, isLiveEdit: boolean, sourceMapURL: string|undefined,
-      hasSourceURL: boolean, length: number, isModule: boolean|null, originStackTrace: Protocol.Runtime.StackTrace|null,
-      codeOffset: number|null, scriptLanguage: string|null, debugSymbols: Protocol.Debugger.DebugSymbols|null,
-      embedderName: Platform.DevToolsPath.UrlString|null, buildId: string|null) {
+  constructor(debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId,
+              sourceURL: Platform.DevToolsPath.UrlString, startLine: number, startColumn: number, endLine: number,
+              endColumn: number, executionContextId: number, hash: string, isContentScript: boolean,
+              sourceMapURL: string|undefined, hasSourceURL: boolean, length: number, isModule: boolean|null,
+              originStackTrace: Protocol.Runtime.StackTrace|null, codeOffset: number|null, scriptLanguage: string|null,
+              debugSymbols: Protocol.Debugger.DebugSymbols|null, embedderName: Platform.DevToolsPath.UrlString|null,
+              buildId: string|null) {
     this.debuggerModel = debuggerModel;
     this.scriptId = scriptId;
     this.sourceURL = sourceURL;
@@ -112,7 +110,6 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     this.executionContextId = executionContextId;
     this.hash = hash;
     this.#isContentScript = isContentScript;
-    this.#isLiveEdit = isLiveEdit;
     this.sourceMapURL = sourceMapURL;
     this.debugSymbols = debugSymbols;
     this.hasSourceURL = hasSourceURL;
@@ -175,10 +172,6 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     return this.debuggerModel.runtimeModel().executionContext(this.executionContextId);
   }
 
-  isLiveEdit(): boolean {
-    return this.#isLiveEdit;
-  }
-
   contentURL(): Platform.DevToolsPath.UrlString {
     return this.sourceURL;
   }
@@ -261,8 +254,8 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
   requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError> {
     if (!this.#contentPromise) {
       const fileSizeToCache = 65535;  // We won't bother cacheing files under 64K
-      if (this.hash && !this.#isLiveEdit && this.contentLength > fileSizeToCache) {
-        // For large files that aren't live edits and have a hash, we keep a content-addressed cache
+      if (this.hash && this.contentLength > fileSizeToCache) {
+        // For large files that have a hash, we keep a content-addressed cache
         // so we don't need to load multiple copies or disassemble wasm modules multiple times.
         if (!scriptCacheInstance) {
           // Initialize script cache singleton. Add a finalizer for removing keys from the map.
@@ -331,43 +324,6 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     return TextUtils.TextUtils.performSearchInSearchMatches(matches.result || [], query, caseSensitive, isRegex);
   }
 
-  private appendSourceURLCommentIfNeeded(source: string): string {
-    if (!this.hasSourceURL) {
-      return source;
-    }
-    return source + '\n //# sourceURL=' + this.sourceURL;
-  }
-
-  async editSource(newSource: string): Promise<{
-    changed: boolean,
-    status: Protocol.Debugger.SetScriptSourceResponseStatus,
-    exceptionDetails?: Protocol.Runtime.ExceptionDetails,
-  }> {
-    newSource = Script.trimSourceURLComment(newSource);
-    // We append correct #sourceURL to script for consistency only. It's not actually needed for things to work correctly.
-    newSource = this.appendSourceURLCommentIfNeeded(newSource);
-
-    const oldSource = TextUtils.ContentData.ContentData.textOr(await this.requestContentData(), null);
-    if (oldSource === newSource) {
-      return {changed: false, status: Protocol.Debugger.SetScriptSourceResponseStatus.Ok};
-    }
-    const response = await this.debuggerModel.target().debuggerAgent().invoke_setScriptSource(
-        {scriptId: this.scriptId, scriptSource: newSource, allowTopFrameEditing: true});
-    if (response.getError()) {
-      // Something went seriously wrong, like the V8 inspector no longer knowing about this script without
-      // shutting down the Debugger agent etc.
-      throw new Error(`Script#editSource failed for script with id ${this.scriptId}: ${response.getError()}`);
-    }
-
-    if (!response.getError() && response.status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
-      this.#contentPromise =
-          Promise.resolve(new TextUtils.ContentData.ContentData(newSource, /* isBase64 */ false, 'text/javascript'));
-    }
-
-    this.debuggerModel.dispatchEventToListeners(Events.ScriptSourceWasEdited, {script: this, status: response.status});
-    return {changed: true, status: response.status, exceptionDetails: response.exceptionDetails};
-  }
-
   rawLocation(lineNumber: number, columnNumber: number): Location|null {
     if (this.containsLocation(lineNumber, columnNumber)) {
       return new Location(this.debuggerModel, this.scriptId, lineNumber, columnNumber);

package/front_end/core/sdk/TargetManager.ts

@@ -122,6 +122,24 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     Root.DevToolsContext.globalInstance().delete(TargetManager);
   }
 
+  // TODO(crbug.com/542394587): Should be `Symbol.dispose`
+  dispose(): void {
+    for (const target of this.targets()) {
+      target.dispose('TargetManager disposed');
+    }
+    if (this.#browserTarget) {
+      this.#browserTarget.dispose('TargetManager disposed');
+      this.#browserTarget = null;
+    }
+    this.#targets.clear();
+    this.#observers.clear();
+    this.#modelObservers.clear();
+    this.#modelListeners.clear();
+    this.#scopeChangeListeners.clear();
+    this.#scopeTarget = null;
+    this.#scopedObservers = new WeakSet();
+  }
+
   onInspectedURLChange(target: Target): void {
     if (target !== this.#scopeTarget) {
       return;

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -501,21 +501,11 @@ export class HeapSnapshotNode implements HeapSnapshotItem {
   }
 
   #detachednessAndClassIndex(): number {
-    const {snapshot, nodeIndex} = this;
-    const nodeDetachednessAndClassIndexOffset = snapshot.nodeDetachednessAndClassIndexOffset;
-    return nodeDetachednessAndClassIndexOffset !== -1 ?
-        snapshot.nodes.getValue(nodeIndex + nodeDetachednessAndClassIndexOffset) :
-        (snapshot.detachednessAndClassIndexArray as Uint32Array)[nodeIndex / snapshot.nodeFieldCount];
+    return this.snapshot.detachednessAndClassIndexArray[this.nodeIndex / this.snapshot.nodeFieldCount];
   }
 
   #setDetachednessAndClassIndex(value: number): void {
-    const {snapshot, nodeIndex} = this;
-    const nodeDetachednessAndClassIndexOffset = snapshot.nodeDetachednessAndClassIndexOffset;
-    if (nodeDetachednessAndClassIndexOffset !== -1) {
-      snapshot.nodes.setValue(nodeIndex + nodeDetachednessAndClassIndexOffset, value);
-    } else {
-      (snapshot.detachednessAndClassIndexArray as Uint32Array)[nodeIndex / snapshot.nodeFieldCount] = value;
-    }
+    this.snapshot.detachednessAndClassIndexArray[this.nodeIndex / this.snapshot.nodeFieldCount] = value;
   }
 
   detachedness(): HeapSnapshotModel.HeapSnapshotModel.DOMLinkState {
@@ -1010,7 +1000,7 @@ export abstract class HeapSnapshot {
   #ignoredEdgesInRetainersView = new Set<number>();
   #nodeDistancesForRetainersView: Int32Array|undefined;
   #edgeNamesThatAreNotWeakMaps: Platform.TypedArrayUtilities.BitVector;
-  detachednessAndClassIndexArray?: Uint32Array;
+  detachednessAndClassIndexArray!: Uint32Array;
   nodeNativeContextAttribution!: Int32Array;
   #nativeContextSizes!: HeapSnapshotModel.HeapSnapshotModel.NativeContextSizes;
   #nativeContextOrdinals!: number[];
@@ -1092,6 +1082,7 @@ export abstract class HeapSnapshot {
     this.#progress.updateStatus('Building retainers…');
     const resultsFromSecondWorker = this.startInitStep1InSecondThread(secondWorker);
     this.#progress.updateStatus('Propagating DOM state…');
+    this.initDetachednessAndClassIndex();
     this.propagateDOMState();
     this.#progress.updateStatus('Calculating node flags…');
     this.calculateFlags();
@@ -2400,12 +2391,6 @@ export abstract class HeapSnapshot {
       nodeRegExpType,
     } = this;
 
-    // If the snapshot doesn't contain a detachedness field in each node, then
-    // allocate a separate array so there is somewhere to store the class index.
-    if (this.nodeDetachednessAndClassIndexOffset === -1) {
-      this.detachednessAndClassIndexArray = new Uint32Array(nodeCount);
-    }
-
     // We'll add some new values to the `strings` array during the processing below.
     // This map lets us easily find the index for each added string.
     const stringTable = new Map<string, number>();
@@ -2707,6 +2692,49 @@ export abstract class HeapSnapshot {
     return this.#nativeContextSizes;
   }
 
+  getRetainedByContextSummary(): HeapSnapshotModel.HeapSnapshotModel.RetainedByContextSummary {
+    // Use the exact same implementation here as aggregateWithFilter('objectsRetainedByContexts').
+    const isRetainedByContext = this.createNamedFilter('objectsRetainedByContexts');
+
+    let contextCount = 0;
+    let retainedByContextSize = 0;
+    let retainedByContextCount = 0;
+    let notRetainedByContextSize = 0;
+    let notRetainedByContextCount = 0;
+
+    const node = this.rootNode();
+    const {nodes, nodeFieldCount, nodeSelfSizeOffset: selfSizeOffset} = this;
+    const nodesLength = nodes.length;
+
+    for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+      const selfSize = nodes.getValue(nodeIndex + selfSizeOffset);
+      if (!selfSize) {
+        continue;
+      }
+      node.nodeIndex = nodeIndex;
+      if (isRetainedByContext(node)) {
+        retainedByContextCount++;
+        retainedByContextSize += selfSize;
+      } else {
+        notRetainedByContextCount++;
+        notRetainedByContextSize += selfSize;
+      }
+
+      if (this.isContextObject(node)) {
+        contextCount++;
+      }
+    }
+
+    return {
+      contextCount,
+      retainedByContextSize,
+      retainedByContextCount,
+      notRetainedByContextSize,
+      notRetainedByContextCount,
+      totalSize: retainedByContextSize + notRetainedByContextSize,
+    };
+  }
+
   nodeNativeContext(nodeIndex: number): number {
     const ordinal = nodeIndex / this.nodeFieldCount;
     const nativeContextOrdinal = this.nodeNativeContextAttribution[ordinal];
@@ -2987,6 +3015,30 @@ export abstract class HeapSnapshot {
     return null;
   }
 
+  private initDetachednessAndClassIndex(): void {
+    this.detachednessAndClassIndexArray = new Uint32Array(this.nodeCount);
+    if (this.nodeDetachednessAndClassIndexOffset !== -1) {
+      // Seed this array from the detachedness field of the snapshot.
+      const {nodeFieldCount, nodeDetachednessAndClassIndexOffset: offset} = this;
+      for (let i = 0; i < this.nodeCount; ++i) {
+        this.detachednessAndClassIndexArray[i] = Number(this.nodes.getValue(i * nodeFieldCount + offset));
+      }
+    } else {
+      // For old snapshots, treat native objects named 'Detached ...' as detached.
+      const node = this.rootNode();
+      const nodesLength = this.nodes.length;
+      const {nodeFieldCount, nodeNativeType, nodeTypeOffset} = this;
+      for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+        if (this.nodes.getValue(nodeIndex + nodeTypeOffset) === nodeNativeType) {
+          node.nodeIndex = nodeIndex;
+          if (node.name().startsWith('Detached ')) {
+            node.setDetachedness(HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * The phase propagates whether a node is attached or detached through the
    * graph and adjusts the low-level representation of nodes.
@@ -3292,11 +3344,58 @@ export abstract class HeapSnapshot {
     return null;
   }
 
-  createEdgesProvider(nodeIndex: number): HeapSnapshotEdgesProvider {
+  createEdgesProvider(nodeIndex: number,
+                      options?: HeapSnapshotModel.HeapSnapshotModel.HeapEdgesQueryOptions): HeapSnapshotEdgesProvider {
     const node = this.createNode(nodeIndex);
-    const filter = this.containmentEdgesFilter();
+    const defaultFilter = this.containmentEdgesFilter();
+    const minRetainedSize = options?.minRetainedSize;
+    const excludePrimitives = options?.excludePrimitives ?? false;
+
+    let filter: ((arg0: HeapSnapshotEdge) => boolean)|null = defaultFilter;
+
+    if (minRetainedSize !== undefined || excludePrimitives) {
+      filter = (edge: HeapSnapshotEdge): boolean => {
+        if (defaultFilter && !defaultFilter(edge)) {
+          return false;
+        }
+        const targetNode = edge.node();
+        if (minRetainedSize !== undefined && targetNode.retainedSize() < minRetainedSize) {
+          return false;
+        }
+        if (excludePrimitives) {
+          const rawType = targetNode.rawType();
+          if (rawType === this.nodeNumberType) {
+            return false;
+          }
+          if (rawType === this.nodeNativeType) {
+            const targetName = targetNode.rawName();
+            if (targetName === 'undefined' || targetName === 'null' || targetName === 'true' ||
+                targetName === 'false') {
+              return false;
+            }
+          }
+        }
+        return true;
+      };
+    }
+
     const indexProvider = new HeapSnapshotEdgeIndexProvider(this);
-    return new HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
+    const provider = new HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
+
+    if (options?.sortBy) {
+      const sortBy = options.sortBy;
+      let comparator: HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig;
+      if (sortBy === 'selfSize') {
+        comparator = new HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig('selfSize', false, '!edgeName', true);
+      } else if (sortBy === 'name') {
+        comparator = new HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig('!edgeName', true, 'retainedSize', false);
+      } else {
+        comparator = new HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig('retainedSize', false, '!edgeName', true);
+      }
+      provider.sortAndRewind(comparator);
+    }
+
+    return provider;
   }
 
   createEdgesProviderForTest(nodeIndex: number, filter: ((arg0: HeapSnapshotEdge) => boolean)|null):
@@ -3512,6 +3611,97 @@ export abstract class HeapSnapshot {
     return new HeapSnapshotNodesProvider(this, this.aggregatesWithFilter(nodeFilter)[classKey].idxs);
   }
 
+  queryObjects(queryOptions: HeapSnapshotModel.HeapSnapshotModel.HeapQueryOptions): HeapSnapshotNodesProvider {
+    const {nodes, nodeFieldCount, retainedSizes} = this;
+    const nodesLength = nodes.length;
+
+    const matchingIndexes: number[] = [];
+
+    const classNamePattern = queryOptions.className ? new RegExp(queryOptions.className, 'i') : null;
+    const propertyNamePattern = queryOptions.propertyName ? new RegExp(queryOptions.propertyName, 'i') : null;
+    const targetNodeType = queryOptions.nodeType ? queryOptions.nodeType.toLowerCase() : null;
+
+    const node = this.rootNode();
+
+    for (let nodeIndex = 0, ordinal = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount, ordinal++) {
+      node.nodeIndex = nodeIndex;
+
+      if (queryOptions.minSelfSize !== undefined && node.selfSize() < queryOptions.minSelfSize) {
+        continue;
+      }
+      if (queryOptions.maxSelfSize !== undefined && node.selfSize() > queryOptions.maxSelfSize) {
+        continue;
+      }
+
+      const retainedSize = retainedSizes[ordinal];
+      if (queryOptions.minRetainedSize !== undefined && retainedSize < queryOptions.minRetainedSize) {
+        continue;
+      }
+      if (queryOptions.maxRetainedSize !== undefined && retainedSize > queryOptions.maxRetainedSize) {
+        continue;
+      }
+
+      if (queryOptions.isDetached !== undefined) {
+        const isDetached = node.detachedness() === HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED;
+        if (isDetached !== queryOptions.isDetached) {
+          continue;
+        }
+      }
+
+      if (classNamePattern) {
+        const name = node.name();
+        if (!classNamePattern.test(name)) {
+          continue;
+        }
+      }
+
+      if (targetNodeType) {
+        const typeStr = node.type();
+        if (typeStr.toLowerCase() !== targetNodeType) {
+          continue;
+        }
+      }
+
+      if (propertyNamePattern) {
+        let propMatch = false;
+        for (const iter = node.edges(); iter.hasNext(); iter.next()) {
+          if (propertyNamePattern.test(iter.edge.name())) {
+            propMatch = true;
+            break;
+          }
+        }
+        if (!propMatch) {
+          continue;
+        }
+      }
+
+      matchingIndexes.push(nodeIndex);
+    }
+
+    const sortBy = queryOptions.sortBy ?? 'retainedSize';
+    if (sortBy === 'retainedSize') {
+      matchingIndexes.sort((a, b) => retainedSizes[b / nodeFieldCount] - retainedSizes[a / nodeFieldCount]);
+    } else if (sortBy === 'selfSize') {
+      matchingIndexes.sort((a, b) => {
+        node.nodeIndex = b;
+        const sizeB = node.selfSize();
+        node.nodeIndex = a;
+        const sizeA = node.selfSize();
+        return sizeB - sizeA;
+      });
+    } else if (sortBy === 'id') {
+      matchingIndexes.sort((a, b) => {
+        node.nodeIndex = b;
+        const idB = node.id();
+        node.nodeIndex = a;
+        const idA = node.id();
+        return idA - idB;
+      });
+    }
+
+    return new HeapSnapshotNodesProvider(this, matchingIndexes);
+  }
+
   private maxJsNodeId(): number {
     const nodeFieldCount = this.nodeFieldCount;
     const nodes = this.nodes;
@@ -4196,7 +4386,7 @@ export class JSHeapSnapshot extends HeapSnapshot {
         continue;
       }
       node.nodeIndex = nodeIndex;
-      if (node.name().startsWith('Detached ')) {
+      if (node.detachedness() === HeapSnapshotModel.HeapSnapshotModel.DOMLinkState.DETACHED) {
         this.flags[ordinal] |= flag;
       }
     }

package/front_end/entrypoints/main/MainImpl.ts

@@ -49,6 +49,7 @@ import * as Persistence from '../../models/persistence/persistence.js';
 import * as Workspace from '../../models/workspace/workspace.js';
 import * as PanelCommon from '../../panels/common/common.js';
 import * as Snippets from '../../panels/snippets/snippets.js';
+import type * as Comments from '../../ui/comments/comments.js';
 import * as Buttons from '../../ui/components/buttons/buttons.js';
 import * as Snackbar from '../../ui/components/snackbars/snackbars.js';
 import * as UIHelpers from '../../ui/helpers/helpers.js';
@@ -209,6 +210,7 @@ export class MainImpl {
       hostConfig: Root.Runtime.hostConfig,
       inspectorFrontendHost: Host.InspectorFrontendHost.InspectorFrontendHostInstance,
       supportsEmulation: this.#supportsEmulation,
+      initAutomaticFilesystem: true,
     };
     this.#universe = new Foundation.Universe.Universe(creationOptions);
     Root.DevToolsContext.setGlobalInstance(this.#universe.context as Root.DevToolsContext.WritableDevToolsContext);
@@ -997,3 +999,33 @@ export class ReloadActionDelegate implements UI.ActionRegistration.ActionDelegat
     return false;
   }
 }
+
+let activeCommentManager: Comments.CommentManager.CommentManager|null = null;
+let activeOverlayWidget: Comments.CommentsOverlayWidget.CommentsOverlayWidget|null = null;
+
+// Temporary for manual testing and experimentation.
+export async function comments(): Promise<Comments.CommentManager.CommentManager> {
+  const Comments = await import('../../ui/comments/comments.js');
+  if (!activeCommentManager || !activeOverlayWidget) {
+    activeCommentManager = new Comments.CommentManager.CommentManager();
+    activeCommentManager.start();
+
+    activeOverlayWidget = new Comments.CommentsOverlayWidget.CommentsOverlayWidget(activeCommentManager);
+    activeOverlayWidget.markAsRoot();
+    activeOverlayWidget.show(document.body);
+    activeCommentManager.setCommentMode(true);
+    return activeCommentManager;
+  }
+
+  const newMode = !activeCommentManager.isCommentMode();
+  activeCommentManager.setCommentMode(newMode);
+  if (newMode) {
+    activeOverlayWidget.show(document.body);
+  } else {
+    activeOverlayWidget.detach();
+  }
+  return activeCommentManager;
+}
+
+// @ts-expect-error global helper for manual testing
+globalThis.comments = comments;

package/front_end/foundation/Universe.ts

@@ -28,6 +28,7 @@ export interface CreationOptions {
   hostConfig: Root.Runtime.HostConfig;
   inspectorFrontendHost: Host.InspectorFrontendHostAPI.InspectorFrontendHostAPI;
   supportsEmulation: boolean;
+  initAutomaticFilesystem?: boolean;
 }
 
 export class Universe {
@@ -37,6 +38,7 @@ export class Universe {
   readonly context: Root.DevToolsContext.DevToolsContext;
   readonly autofillManager: AutofillManager.AutofillManager.AutofillManager;
   readonly supportsEmulation: boolean;
+  readonly initAutomaticFilesystem: boolean;
   readonly fileSystemWorkspaceBinding: Persistence.FileSystemWorkspaceBinding.FileSystemWorkspaceBinding;
 
   constructor(options: CreationOptions) {
@@ -78,11 +80,17 @@ 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);
+      deviceModeModel = new Emulation.DeviceModeModel.DeviceModeModel(targetManager, settings,
+                                                                      multitargetNetworkManager, fileManager);
       context.set(Emulation.DeviceModeModel.DeviceModeModel, deviceModeModel);
     }
 
@@ -90,15 +98,20 @@ export class Universe {
         new SDK.PageResourceLoader.PageResourceLoader(targetManager, settings, multitargetNetworkManager, null);
     context.set(SDK.PageResourceLoader.PageResourceLoader, pageResourceLoader);
 
-    const projectSettingsModel = new ProjectSettings.ProjectSettingsModel.ProjectSettingsModel(
-        pageResourceLoader,
-        targetManager,
-    );
-    context.set(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel, projectSettingsModel);
-
-    const automaticFileSystemManager = new Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager(
-        options.inspectorFrontendHost, projectSettingsModel);
-    context.set(Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager, automaticFileSystemManager);
+    this.initAutomaticFilesystem = options.initAutomaticFilesystem ?? false;
+    let automaticFileSystemManager = null;
+    let projectSettingsModel = null;
+    if (this.initAutomaticFilesystem) {
+      projectSettingsModel = new ProjectSettings.ProjectSettingsModel.ProjectSettingsModel(
+          pageResourceLoader,
+          targetManager,
+      );
+      context.set(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel, projectSettingsModel);
+
+      automaticFileSystemManager = new Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager(
+          options.inspectorFrontendHost, projectSettingsModel);
+      context.set(Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager, automaticFileSystemManager);
+    }
 
     const cpuThrottlingManager = new SDK.CPUThrottlingManager.CPUThrottlingManager(settings, targetManager);
     context.set(SDK.CPUThrottlingManager.CPUThrottlingManager, cpuThrottlingManager);
@@ -117,22 +130,18 @@ 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);
-
-    const automaticFileSystemWorkspaceBinding =
-        new Persistence.AutomaticFileSystemWorkspaceBinding.AutomaticFileSystemWorkspaceBinding(
-            automaticFileSystemManager,
-            isolatedFileSystemManager,
-            workspace,
-        );
-    context.set(
-        Persistence.AutomaticFileSystemWorkspaceBinding.AutomaticFileSystemWorkspaceBinding,
-        automaticFileSystemWorkspaceBinding,
-    );
+    if (automaticFileSystemManager) {
+      const automaticFileSystemWorkspaceBinding =
+          new Persistence.AutomaticFileSystemWorkspaceBinding.AutomaticFileSystemWorkspaceBinding(
+              automaticFileSystemManager,
+              isolatedFileSystemManager,
+              workspace,
+          );
+      context.set(
+          Persistence.AutomaticFileSystemWorkspaceBinding.AutomaticFileSystemWorkspaceBinding,
+          automaticFileSystemWorkspaceBinding,
+      );
+    }
 
     this.fileSystemWorkspaceBinding =
         new Persistence.FileSystemWorkspaceBinding.FileSystemWorkspaceBinding(isolatedFileSystemManager, workspace);
@@ -226,6 +235,11 @@ export class Universe {
   dispose(): void {
     // TODO(crbug.com/542394587): Track these in a DisposableStack.
     this.context.get(Persistence.IsolatedFileSystemManager.IsolatedFileSystemManager).dispose();
+    if (this.initAutomaticFilesystem) {
+      this.context.get(Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager).dispose();
+    }
+    this.context.get(Workspace.FileManager.FileManager).dispose();
+    this.context.get(SDK.TargetManager.TargetManager).dispose();
   }
 
   get automaticFileSystemManager(): Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager {
@@ -338,8 +352,9 @@ export class Universe {
     return this.context.get(Bindings.PresentationConsoleMessageHelper.PresentationConsoleMessageManager);
   }
 
-  get projectSettingsModel(): ProjectSettings.ProjectSettingsModel.ProjectSettingsModel {
-    return this.context.get(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+  get projectSettingsModel(): ProjectSettings.ProjectSettingsModel.ProjectSettingsModel|null {
+    return this.initAutomaticFilesystem ? this.context.get(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel) :
+                                          null;
   }
 
   get settings(): Common.Settings.Settings {