chrome-devtools-frontend 1.0.1697998 → 1.0.1698733

package/front_end/models/ai_assistance/tools/ListSources.ts

@@ -4,9 +4,7 @@
 
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import type * as SDK from '../../../core/sdk/sdk.js';
 import * as Workspace from '../../workspace/workspace.js';
-import {FileContext} from '../contexts/FileContext.js';
 
 import {
   type BaseToolCapability,
@@ -50,23 +48,30 @@ export class ListSourcesTool implements
   }
 
   static getUISourceCodes(
-      establishedOrigin: SDK.SecurityOrigin.SecurityOrigin,
+      originLock: OriginLockState,
       // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       workspace: Workspace.Workspace.WorkspaceImpl = Workspace.Workspace.WorkspaceImpl.instance(),
       ): Workspace.UISourceCode.UISourceCode[] {
-    if (establishedOrigin.isOpaque()) {
+    if (originLock.status !== 'ESTABLISHED_ORIGIN' || originLock.origin.isOpaque()) {
       return [];
     }
 
-    const projects =
-        workspace.projects().filter(project => project.type() === Workspace.Workspace.projectTypes.Network);
     const uiSourceCodes = new Map<string, Workspace.UISourceCode.UISourceCode>();
 
-    for (const project of projects) {
+    for (const project of workspace.projectsForType(Workspace.Workspace.projectTypes.Network)) {
+      const projectOrigin = project.securityOrigin?.();
+      if (projectOrigin && !isOriginAllowedByLock(originLock, projectOrigin)) {
+        continue;
+      }
+
       for (const uiSourceCode of project.uiSourceCodes()) {
         if (uiSourceCode.isIgnoreListed()) {
           continue;
         }
+        if (!projectOrigin && !isOriginAllowedByLock(originLock, uiSourceCode.securityOrigin())) {
+          continue;
+        }
+
         const url = uiSourceCode.url();
         if (!uiSourceCodes.get(url) || uiSourceCode.contentType().isFromSourceMap()) {
           uiSourceCodes.set(url, uiSourceCode);
@@ -77,18 +82,19 @@ export class ListSourcesTool implements
       }
     }
 
-    const originLock: OriginLockState = {status: 'ESTABLISHED_ORIGIN', origin: establishedOrigin};
-    return [...uiSourceCodes.values()].filter(
-        file => isOriginAllowedByLock(originLock, FileContext.originForUISourceCode(file)));
+    return Array.from(uiSourceCodes.values());
   }
 
   static getSourceById(
       id: number,
-      establishedOrigin: SDK.SecurityOrigin.SecurityOrigin,
+      originLock: OriginLockState,
       // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       workspace: Workspace.Workspace.WorkspaceImpl = Workspace.Workspace.WorkspaceImpl.instance(),
       ): Workspace.UISourceCode.UISourceCode|undefined {
-    return ListSourcesTool.getUISourceCodes(establishedOrigin, workspace)
+    if (!Number.isInteger(id) || id <= 0) {
+      return undefined;
+    }
+    return ListSourcesTool.getUISourceCodes(originLock, workspace)
         .find(file => ListSourcesTool.uiSourceCodeId.get(file) === id);
   }
 
@@ -114,12 +120,13 @@ export class ListSourcesTool implements
       _params: Record<string, never>,
       context: BaseToolCapability&OriginLockCapability,
       ): Promise<DataHandlerResult<{files: SourceSummary[]}>> {
-    const originResult = resolveOriginFromLock(context.getOriginLock());
+    const originLock = context.getOriginLock();
+    const originResult = resolveOriginFromLock(originLock);
     if ('error' in originResult) {
       return originResult;
     }
 
-    const files = ListSourcesTool.getUISourceCodes(originResult.origin);
+    const files = ListSourcesTool.getUISourceCodes(originLock);
 
     return {
       result: {

package/front_end/models/bindings/CompilerScriptMapping.ts

@@ -458,16 +458,9 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     this.removeStubUISourceCode(script);
 
     const target = script.target();
-    const embedderName = script.embedderName();
-    let securityOrigin: SDK.SecurityOrigin.SecurityOrigin|undefined;
-    if (embedderName) {
-      const extractedOrigin = Common.ParsedURL.ParsedURL.extractOrigin(embedderName);
-      if (extractedOrigin && extractedOrigin !== 'null') {
-        securityOrigin = SDK.SecurityOrigin.SecurityOrigin.create(extractedOrigin);
-      }
-    }
-    const parsedOrigin = securityOrigin ? `:${securityOrigin.siteId()}` : '';
-    const projectId = `jsSourceMaps:${script.isContentScript() ? 'extensions' : ''}:${target.id()}${parsedOrigin}`;
+    const securityOrigin = script.securityOrigin();
+    const originPart = securityOrigin.isOpaque() ? '' : `:${securityOrigin.siteId()}`;
+    const projectId = `jsSourceMaps:${script.isContentScript() ? 'extensions' : ''}:${target.id()}${originPart}`;
     let project = this.#projects.get(projectId);
     if (!project) {
       const projectType = script.isContentScript() ? Workspace.Workspace.projectTypes.ContentScripts :

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -593,11 +593,11 @@ export class DebuggerLanguagePluginManager implements
     return {rawModuleId, plugin: null};
   }
 
-  uiSourceCodeForURL(debuggerModel: SDK.DebuggerModel.DebuggerModel, url: Platform.DevToolsPath.UrlString):
-      Workspace.UISourceCode.UISourceCode|null {
+  uiSourceCodeForURL(debuggerModel: SDK.DebuggerModel.DebuggerModel, url: Platform.DevToolsPath.UrlString,
+                     script?: SDK.Script.Script): Workspace.UISourceCode.UISourceCode|null {
     const modelData = this.#debuggerModelToData.get(debuggerModel);
     if (modelData) {
-      return modelData.getProject().uiSourceCodeForURL(url);
+      return modelData.uiSourceCodeForURL(url, script);
     }
     return null;
   }
@@ -625,7 +625,7 @@ export class DebuggerLanguagePluginManager implements
       const sourceLocations = await plugin.rawLocationToSourceLocation(pluginLocation);
       for (const sourceLocation of sourceLocations) {
         const uiSourceCode = this.uiSourceCodeForURL(
-            script.debuggerModel, sourceLocation.sourceFileURL as Platform.DevToolsPath.UrlString);
+            script.debuggerModel, sourceLocation.sourceFileURL as Platform.DevToolsPath.UrlString, script);
         if (!uiSourceCode) {
           continue;
         }
@@ -1097,23 +1097,41 @@ export class DebuggerLanguagePluginManager implements
 }
 
 class ModelData {
-  project: ContentProviderBasedProject;
+  readonly #debuggerModel: SDK.DebuggerModel.DebuggerModel;
+  readonly #workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly #projects = new Map<string, ContentProviderBasedProject>();
   readonly uiSourceCodeToScripts: Map<Workspace.UISourceCode.UISourceCode, SDK.Script.Script[]>;
   constructor(debuggerModel: SDK.DebuggerModel.DebuggerModel, workspace: Workspace.Workspace.WorkspaceImpl) {
-    this.project =
-        new ContentProviderBasedProject(workspace, 'language_plugins::' + debuggerModel.target().id(),
-                                        Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
-    NetworkProject.setTargetForProject(this.project, debuggerModel.target());
-
+    this.#debuggerModel = debuggerModel;
+    this.#workspace = workspace;
     this.uiSourceCodeToScripts = new Map();
   }
 
+  #projectIdForScript(script: SDK.Script.Script): string {
+    const securityOrigin = script.securityOrigin();
+    const originPart = securityOrigin.isOpaque() ? '' : `:${securityOrigin.siteId()}`;
+    return `language_plugins::${this.#debuggerModel.target().id()}${originPart}`;
+  }
+
+  #projectForScript(script: SDK.Script.Script): ContentProviderBasedProject {
+    const projectId = this.#projectIdForScript(script);
+    let project = this.#projects.get(projectId);
+    if (!project) {
+      project = new ContentProviderBasedProject(this.#workspace, projectId, Workspace.Workspace.projectTypes.Network,
+                                                '', false /* isServiceProject */, script.securityOrigin());
+      NetworkProject.setTargetForProject(project, this.#debuggerModel.target());
+      this.#projects.set(projectId, project);
+    }
+    return project;
+  }
+
   addSourceFiles(script: SDK.Script.Script, urls: Platform.DevToolsPath.UrlString[]): void {
+    const project = this.#projectForScript(script);
     const initiator = script.createPageResourceLoadInitiator();
     for (const url of urls) {
-      let uiSourceCode = this.project.uiSourceCodeForURL(url);
+      let uiSourceCode = project.uiSourceCodeForURL(url);
       if (!uiSourceCode) {
-        uiSourceCode = this.project.createUISourceCode(url, Common.ResourceType.resourceTypes.SourceMapScript);
+        uiSourceCode = project.createUISourceCode(url, Common.ResourceType.resourceTypes.SourceMapScript);
         NetworkProject.setInitialFrameAttribution(uiSourceCode, script.frameId);
 
         // Bind the uiSourceCode to the script first before we add the
@@ -1129,7 +1147,7 @@ class ModelData {
             url, Common.ResourceType.resourceTypes.SourceMapScript, initiator,
             script.target().targetManager().getPageResourceLoader());
         const mimeType = Common.ResourceType.ResourceType.mimeFromURL(url) || 'text/javascript';
-        this.project.addUISourceCodeWithProvider(uiSourceCode, contentProvider, null, mimeType);
+        project.addUISourceCodeWithProvider(uiSourceCode, contentProvider, null, mimeType);
       } else {
         // The same uiSourceCode can be provided by different scripts,
         // but we don't expect that to happen frequently.
@@ -1146,7 +1164,7 @@ class ModelData {
       scripts = scripts.filter(s => s !== script);
       if (scripts.length === 0) {
         this.uiSourceCodeToScripts.delete(uiSourceCode);
-        this.project.removeUISourceCode(uiSourceCode.url());
+        uiSourceCode.project().removeUISourceCode(uiSourceCode.url());
       } else {
         this.uiSourceCodeToScripts.set(uiSourceCode, scripts);
       }
@@ -1154,11 +1172,24 @@ class ModelData {
   }
 
   dispose(): void {
-    this.project.dispose();
+    for (const project of this.#projects.values()) {
+      project.dispose();
+    }
+    this.#projects.clear();
   }
 
-  getProject(): ContentProviderBasedProject {
-    return this.project;
+  uiSourceCodeForURL(url: Platform.DevToolsPath.UrlString,
+                     script?: SDK.Script.Script): Workspace.UISourceCode.UISourceCode|null {
+    if (script) {
+      return this.#projects.get(this.#projectIdForScript(script))?.uiSourceCodeForURL(url) ?? null;
+    }
+    for (const project of this.#projects.values()) {
+      const uiSourceCode = project.uiSourceCodeForURL(url);
+      if (uiSourceCode) {
+        return uiSourceCode;
+      }
+    }
+    return null;
   }
 }
 

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -312,11 +312,11 @@ export class ResourceScriptFile {
     this.script = this.uiSourceCode.contentType().isScript() ? script : null;
   }
 
-  addSourceMapURL(sourceMapURL: Platform.DevToolsPath.UrlString): void {
+  addSourceMapURL(sourceMapURL: Platform.DevToolsPath.UrlString, provenance: SDK.SourceMap.SourceMapProvenance): void {
     if (!this.script) {
       return;
     }
-    this.script.debuggerModel.setSourceMapURL(this.script, sourceMapURL);
+    this.script.debuggerModel.setSourceMapURL(this.script, sourceMapURL, provenance);
   }
 
   addDebugInfoURL(debugInfoURL: Platform.DevToolsPath.UrlString): void {

package/front_end/models/bindings/StylesSourceMapping.ts

@@ -310,7 +310,7 @@ export class StyleFile implements TextUtils.ContentProvider.ContentProvider {
     const sourceMapManager = this.#cssModel.sourceMapManager();
     this.headers.forEach(header => {
       sourceMapManager.detachSourceMap(header);
-      sourceMapManager.attachSourceMap(header, sourceUrl, sourceMapUrl);
+      sourceMapManager.attachSourceMap(header, sourceUrl, sourceMapUrl, SDK.SourceMap.SourceMapProvenance.USER);
     });
   }
 }

package/front_end/models/comment_manager/CD4ABridge.ts

@@ -14,13 +14,12 @@ export interface CommentThread {
   id: string;
   text: string;
   networkRequestId?: string;
-  backendNodeId?: number;
-  editor?: CommentManager.EditorAnchorSignature;
+  node?: CommentManager.DOMNodeAnchorSignature;
 }
 
 export interface RevealTarget {
   networkRequestId?: string;
-  backendNodeId?: number;
+  node?: CommentManager.DOMNodeAnchorSignature;
 }
 
 export const enum Events {
@@ -69,21 +68,65 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     Common.EventTarget.removeEventListeners(this.#eventListeners);
   }
 
+  #getDOMNode(nodeSignature: CommentManager.DOMNodeAnchorSignature): SDK.DOMModel.DOMNode|undefined {
+    if (!this.#targetManager) {
+      return undefined;
+    }
+    const target = this.#targetManager.targetById(nodeSignature.targetId) ?? this.#targetManager.primaryPageTarget();
+    const domModel = target?.model(SDK.DOMModel.DOMModel);
+    if (!domModel) {
+      return undefined;
+    }
+    for (const node of domModel.idToDOMNode.values()) {
+      if (node.backendNodeId() === nodeSignature.backendNodeId) {
+        return node;
+      }
+    }
+    return undefined;
+  }
+
+  #formatCommentText(thread: CommentManager.CommentThread): string {
+    const rawText = thread.comments[0]?.text ?? '';
+    const details: string[] = [];
+
+    if (thread.anchor.textSignature) {
+      details.push(`- DevTools element: ${thread.anchor.textSignature}`);
+    }
+
+    if (thread.anchor.node) {
+      const domNode = this.#getDOMNode(thread.anchor.node);
+      const simpleSelector = domNode?.simpleSelector();
+      if (simpleSelector) {
+        details.push(`- DOM node selector: ${simpleSelector}`);
+      }
+    }
+
+    if (thread.anchor.editor) {
+      const editorInfo = thread.anchor.editor.filePath ?
+          `${thread.anchor.editor.filePath}:${thread.anchor.editor.lineNumber}` :
+          `line ${thread.anchor.editor.lineNumber}`;
+      details.push(`- Editor: ${editorInfo}`);
+    }
+
+    if (details.length === 0) {
+      return rawText;
+    }
+
+    return rawText ? `${rawText}\n\n${details.join('\n')}` : details.join('\n');
+  }
+
   getCommentThreads(): CommentThread[] {
     const threads = this.#commentManager.takeComments();
     return threads.map(thread => {
       const threadPayload: CommentThread = {
         id: thread.id,
-        text: thread.comments[0]?.text ?? '',
+        text: this.#formatCommentText(thread),
       };
       if (thread.anchor.networkRequestId) {
         threadPayload.networkRequestId = thread.anchor.networkRequestId;
       }
       if (thread.anchor.node) {
-        threadPayload.backendNodeId = thread.anchor.node.backendNodeId;
-      }
-      if (thread.anchor.editor) {
-        threadPayload.editor = thread.anchor.editor;
+        threadPayload.node = {...thread.anchor.node};
       }
       return threadPayload;
     });
@@ -112,11 +155,11 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
       }
     }
 
-    if (target?.backendNodeId !== undefined && this.#targetManager) {
-      const primaryTarget = this.#targetManager.primaryPageTarget();
-      const domModel = primaryTarget?.model(SDK.DOMModel.DOMModel);
+    if (target?.node && this.#targetManager) {
+      const sdkTarget = this.#targetManager.targetById(target.node.targetId) ?? this.#targetManager.primaryPageTarget();
+      const domModel = sdkTarget?.model(SDK.DOMModel.DOMModel);
       if (domModel) {
-        const cdpNodeId = target.backendNodeId as Protocol.DOM.BackendNodeId;
+        const cdpNodeId = target.node.backendNodeId as Protocol.DOM.BackendNodeId;
         const nodeMap = await domModel.pushNodesByBackendIdsToFrontend(new Set([cdpNodeId]));
         const node = nodeMap?.get(cdpNodeId);
         if (node) {

package/front_end/models/comment_manager/CommentManager.ts

@@ -4,75 +4,30 @@
 
 import * as Common from '../../core/common/common.js';
 
-export interface EditorAnchorSignature {
-  /** 1-based line number for CodeMirror text editor anchors */
-  lineNumber: number;
-  /** File path associated with the editor */
-  filePath?: string;
-}
-
-export interface DOMNodeAnchorSignature {
-  /** Backend NodeId for DOM nodes (`data-backend-node-id`) */
-  backendNodeId: number;
-  /** Target ID associated with the DOM node (`data-target-id`) */
-  targetId: string;
-}
-
-export interface TimelineAnchorSignature {
-  /** Identifier of the trace to scope comments to a specific recording */
-  traceId: string;
-  /** Serializable key from Trace.EventsSerializer (e.g. 'r-123', 'p-1-2-3-4', 's-5') */
-  traceEventKey: string;
-  /** Primary event title or category name */
-  entryName: string;
-  /** Event start timestamp in microseconds */
-  startTimeMicro: number;
-  /** Chart location */
-  chartLocation: 'main'|'network';
-  /** Event duration in microseconds (omitted for instant markers) */
-  durationMicro?: number;
-}
-
-export interface CommentAnchorSignature {
-  /** Visual logging tree path, e.g. "Panel: elements > Pane: styles > TreeOutline > TreeItem: color" */
-  vePath: string;
-  /** Normalized text content of the target node */
-  textSignature: string;
-  /** Text content of the parent container VE node for sibling disambiguation */
-  parentTextSignature?: string;
-  /** 0-indexed position among siblings sharing the same visual logging path */
-  siblingIndex?: number;
-  /** Optional backend RequestId for Network panel elements (`data-network-request-id`) */
-  networkRequestId?: string;
-  /** Optional DOM node identifiers (`data-backend-node-id`, `data-target-id`) */
-  node?: DOMNodeAnchorSignature;
-  /** Optional editor anchor coordinates for CodeMirror text editors */
-  editor?: EditorAnchorSignature;
-  /** Optional timeline flamechart anchor coordinates for Performance panel trace entries */
-  timeline?: TimelineAnchorSignature;
-}
-
-export interface Comment {
-  author: 'DEVELOPER'|'AGENT';
-  text: string;
-  timestamp: number;
-}
-
-export interface ChangeRecord {
-  id: string;
-  description: string;
-  timestamp: number;
-}
-
-export interface CommentThread {
-  id: string;
-  anchor: CommentAnchorSignature;
-  comments: Comment[];
-  status: 'ACTIVE'|'RESOLVED';
-  transmitted?: boolean;
-  changes?: ChangeRecord[];
-  index: number;
-}
+import {
+  type ChangeRecord,
+  type Comment,
+  type CommentAnchorSignature,
+  CommentThread,
+  type CommentThreadOptions,
+  type CommentThreadStatus,
+  type DOMNodeAnchorSignature,
+  type EditorAnchorSignature,
+  Events as CommentThreadEvents,
+  type TimelineAnchorSignature,
+} from './CommentThread.js';
+
+export {
+  type ChangeRecord,
+  type Comment,
+  type CommentAnchorSignature,
+  CommentThread,
+  type CommentThreadOptions,
+  type CommentThreadStatus,
+  type DOMNodeAnchorSignature,
+  type EditorAnchorSignature,
+  type TimelineAnchorSignature,
+};
 
 export const enum Events {
   COMMENT_THREADS_CHANGED = 'CommentThreadsChanged',
@@ -90,7 +45,15 @@ export interface EventTypes {
 export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #commentThreads = new Map<string, CommentThread>();
   #commentMode = false;
-  #nextId = 1;
+
+  constructor() {
+    super();
+    CommentThread.resetIndex();
+  }
+
+  #onThreadChanged(): void {
+    this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
+  }
 
   setCommentMode(active: boolean): void {
     if (this.#commentMode === active) {
@@ -110,25 +73,20 @@ export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventType
       author: 'DEVELOPER'|'AGENT' = 'DEVELOPER',
       changes?: ChangeRecord[],
       ): CommentThread {
-    const index = this.#nextId++;
-    const id = `comment-${index}`;
     const comments: Comment[] = text ? [{
       author,
       text,
       timestamp: Date.now(),
     }] :
                                        [];
-    const thread: CommentThread = {
-      id,
+    const thread = new CommentThread({
       anchor,
       comments,
-      status: 'ACTIVE',
-      transmitted: false,
       changes,
-      index,
-    };
+    });
+    thread.addEventListener(CommentThreadEvents.CHANGED, this.#onThreadChanged, this);
 
-    this.#commentThreads.set(id, thread);
+    this.#commentThreads.set(thread.id, thread);
     this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
     return thread;
   }
@@ -144,7 +102,7 @@ export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventType
   takeComments(): CommentThread[] {
     const threads: CommentThread[] = [];
     for (const thread of this.#commentThreads.values()) {
-      if (!thread.transmitted) {
+      if (thread.status === 'ACTIVE' && !thread.transmitted) {
         thread.transmitted = true;
         threads.push(thread);
       }
@@ -157,30 +115,27 @@ export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     if (!thread) {
       return false;
     }
-    if (replyText && replyText.trim().length > 0) {
-      const comment: Comment = {
-        author: 'AGENT',
-        text: replyText.trim(),
-        timestamp: Date.now(),
-      };
-      thread.comments.push(comment);
-    }
-    thread.status = 'RESOLVED';
-    this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
+    thread.resolve(replyText);
     return true;
   }
 
   removeCommentThread(id: string): void {
-    if (!this.#commentThreads.has(id)) {
+    const thread = this.#commentThreads.get(id);
+    if (!thread) {
       return;
     }
+    thread.removeEventListener(CommentThreadEvents.CHANGED, this.#onThreadChanged, this);
     this.#commentThreads.delete(id);
     this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
   }
 
   clear(): void {
     this.setCommentMode(false);
+    for (const thread of this.#commentThreads.values()) {
+      thread.removeEventListener(CommentThreadEvents.CHANGED, this.#onThreadChanged, this);
+    }
     this.#commentThreads.clear();
+    CommentThread.resetIndex();
     this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, []);
   }
 }