chrome-devtools-frontend 1.0.1699061 → 1.0.1700561

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -14,6 +14,19 @@ import {type DebuggerSourceMapping, DebuggerWorkspaceBinding} from './DebuggerWo
 import {NetworkProject} from './NetworkProject.js';
 import {metadataForURL} from './ResourceUtils.js';
 
+/**
+ * The security origin of the URL that `target` (or its closest ancestor that has
+ * one) is inspecting, or `null` if none of them has an inspected URL yet.
+ */
+function inspectedSecurityOrigin(target: SDK.Target.Target): SDK.SecurityOrigin.SecurityOrigin|null {
+  for (let current: SDK.Target.Target|null = target; current; current = current.parentTarget()) {
+    if (current.inspectedURL()) {
+      return current.inspectedSecurityOrigin();
+    }
+  }
+  return null;
+}
+
 export class ResourceScriptMapping implements DebuggerSourceMapping {
   readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
   #workspace: Workspace.Workspace.WorkspaceImpl;
@@ -197,6 +210,19 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
       // Try to resolve `//# sourceURL=` annotations relative to
       // the base URL, according to the sourcemap specification.
       url = SDK.SourceMapManager.SourceMapManager.resolveRelativeSourceURL(script.debuggerModel.target(), url);
+
+      // `//# sourceURL=` annotations are fully controlled by the page, so don't let
+      // them impersonate a resource of a different origin (b/553931271).
+      if (!this.#isTrustworthySourceURL(script, url)) {
+        return;
+      }
+
+      // Don't let a synthetic source evict the `UISourceCode` of a script that was
+      // actually fetched from the network under the same URL.
+      const previousUISourceCode = this.project(script).uiSourceCodeForURL(url);
+      if (previousUISourceCode && !NetworkProject.isSourceURLSynthesized(previousUISourceCode)) {
+        return;
+      }
     } else {
       // Ignore inline <script>s without `//# sourceURL` annotation here.
       if (script.isInlineScript()) {
@@ -225,6 +251,9 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     // Create UISourceCode.
     const originalContentProvider = script.originalContentProvider();
     const uiSourceCode = project.createUISourceCode(url, originalContentProvider.contentType());
+    if (script.hasSourceURL) {
+      NetworkProject.setSourceURLSynthesized(uiSourceCode);
+    }
     NetworkProject.setInitialFrameAttribution(uiSourceCode, script.frameId);
     const metadata = metadataForURL(this.debuggerModel.target(), script.frameId, url);
 
@@ -238,6 +267,39 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     void this.debuggerWorkspaceBinding.updateLocations(script);
   }
 
+  /**
+   * Whether the (already resolved) `//# sourceURL=` annotation `url` of `script` may
+   * be used as-is.
+   *
+   * Only `http(s)` URLs can collide with genuine network resources, so an origin is
+   * only enforced for those. Annotations using other schemes (e.g. `webpack-internal://`,
+   * `snippet://` or `chrome-extension://` for content scripts) cannot impersonate a
+   * network resource and are always accepted.
+   *
+   * The origin of the script's frame is authoritative. For targets that don't have a
+   * frame (e.g. workers) we fall back to the inspected URL of the target (or of its
+   * closest ancestor that has one). If no origin can be established at all, the
+   * annotation is rejected, since we cannot rule out that it spoofs another origin.
+   */
+  #isTrustworthySourceURL(script: SDK.Script.Script, url: Platform.DevToolsPath.UrlString): boolean {
+    if (script.isContentScript()) {
+      return true;
+    }
+    const parsedURL = Common.ParsedURL.ParsedURL.fromString(url);
+    if (!parsedURL || !['http', 'https'].includes(parsedURL.scheme)) {
+      return true;
+    }
+    const target = script.debuggerModel.target();
+    const frame = script.frameId ?
+        target.model(SDK.ResourceTreeModel.ResourceTreeModel)?.frameForId(script.frameId) ?? null :
+        null;
+    const securityOrigin = frame ? frame.securityOrigin() : inspectedSecurityOrigin(target);
+    if (!securityOrigin) {
+      return false;
+    }
+    return SDK.SecurityOrigin.SecurityOrigin.create(url).isSameOriginWith(securityOrigin);
+  }
+
   scriptFile(uiSourceCode: Workspace.UISourceCode.UISourceCode): ResourceScriptFile|null {
     return this.#uiSourceCodeToScriptFile.get(uiSourceCode) || null;
   }

package/front_end/models/change_tracker/ChangeTracker.ts

@@ -25,7 +25,7 @@ export class ChangeTracker {
   }
 
   get isTracking(): boolean {
-    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled);
+    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled) && this.#commentManager.isAgentAttached();
   }
 
   trackChange(

package/front_end/models/comment_manager/CD4ABridge.ts

@@ -132,8 +132,8 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     });
   }
 
-  takeComments(): CommentThread[] {
-    return this.getCommentThreads();
+  setAgentAttached(value: boolean): void {
+    this.#commentManager.setAgentAttached(value);
   }
 
   resolveCommentThread(threadId: string, replyText?: string): boolean {

package/front_end/models/comment_manager/CommentManager.ts

@@ -32,11 +32,13 @@ export {
 export const enum Events {
   COMMENT_THREADS_CHANGED = 'CommentThreadsChanged',
   COMMENT_MODE_CHANGED = 'CommentModeChanged',
+  AGENT_ATTACHED_CHANGED = 'AgentAttachedChanged',
 }
 
 export interface EventTypes {
   [Events.COMMENT_THREADS_CHANGED]: CommentThread[];
   [Events.COMMENT_MODE_CHANGED]: boolean;
+  [Events.AGENT_ATTACHED_CHANGED]: boolean;
 }
 
 /**
@@ -45,6 +47,7 @@ export interface EventTypes {
 export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #commentThreads = new Map<string, CommentThread>();
   #commentMode = false;
+  #agentAttached = false;
 
   constructor() {
     super();
@@ -55,6 +58,21 @@ export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
   }
 
+  setAgentAttached(value: boolean): void {
+    if (this.#agentAttached === value) {
+      return;
+    }
+    this.#agentAttached = value;
+    if (!value) {
+      this.setCommentMode(false);
+    }
+    this.dispatchEventToListeners(Events.AGENT_ATTACHED_CHANGED, value);
+  }
+
+  isAgentAttached(): boolean {
+    return this.#agentAttached;
+  }
+
   setCommentMode(active: boolean): void {
     if (this.#commentMode === active) {
       return;

package/front_end/models/extensions/ExtensionAPI.ts

@@ -1586,8 +1586,10 @@ globalThis.injectedExtensionAPI = function(
     const targetDocument = targetWindowForTest?.document ?? document;
     const focused = targetDocument.activeElement;
     if (focused) {
-      const isInput =
-          focused.nodeName === 'INPUT' || focused.nodeName === 'TEXTAREA' || (focused as HTMLElement).isContentEditable;
+      // Elements made editable through the EditContext API are not reported as contentEditable.
+      const hasEditContext = 'editContext' in focused && Boolean(focused.editContext);
+      const isInput = focused.nodeName === 'INPUT' || focused.nodeName === 'TEXTAREA' ||
+          (focused as HTMLElement).isContentEditable || hasEditContext;
       if (isInput && !(requestPayload.ctrlKey || requestPayload.altKey || requestPayload.metaKey)) {
         return;
       }

package/front_end/models/issues_manager/CookieIssue.ts

@@ -306,8 +306,6 @@ export function isCausedByThirdParty(
   //     site. Only cookies that have their domain also set to this third-party
   //     are included in the request. We assume that the cookie was set by the same
   //     third-party at some point, so we treat this as a third-party issue.
-  //
-  // TODO(crbug.com/1080589): Use "First-Party sets" instead of the sites registered domain.
   return !isSubdomainOf(parsedCookieUrl.domain(), outermostFrame.domainAndRegistry());
 }
 

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -9,6 +9,7 @@ import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../../core/text_utils/text_utils.js';
 import * as Protocol from '../../generated/protocol.js';
+import * as Bindings from '../bindings/bindings.js';
 import * as Breakpoints from '../breakpoints/breakpoints.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -431,8 +432,32 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   isUISourceCodeOverridable(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
-    return uiSourceCode.project().type() === Workspace.Workspace.projectTypes.Network &&
-        !NetworkPersistenceManager.isForbiddenNetworkUrl(uiSourceCode.url());
+    if (uiSourceCode.project().type() !== Workspace.Workspace.projectTypes.Network) {
+      return false;
+    }
+    if (NetworkPersistenceManager.isForbiddenNetworkUrl(uiSourceCode.url())) {
+      return false;
+    }
+    // A `//# sourceURL=` annotation is fully controlled by the page and doesn't refer
+    // to an actual network resource, so there is nothing to override here. Persisting
+    // it would poison the overrides folder with a file that masquerades as a genuine
+    // resource (b/553931271).
+    if (Bindings.NetworkProject.NetworkProject.isSourceURLSynthesized(uiSourceCode)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Whether the contents of `uiSourceCode` may be written into the overrides folder.
+   *
+   * Sources that originate from a source map are overridable in the sense that the
+   * deployed resource they are mapped from can be overridden (see
+   * `PersistenceActions`), but their own URL and content are page controlled and
+   * must never be persisted themselves (b/553931271).
+   */
+  #canPersistUISourceCodeAsOverride(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    return this.isUISourceCodeOverridable(uiSourceCode) && !uiSourceCode.contentType().isFromSourceMap();
   }
 
   #isUISourceCodeAlreadyOverridden(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
@@ -445,12 +470,12 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   #canSaveUISourceCodeForOverrides(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
-    return this.#active && this.isUISourceCodeOverridable(uiSourceCode) &&
+    return this.#active && this.#canPersistUISourceCodeAsOverride(uiSourceCode) &&
         !this.#isUISourceCodeAlreadyOverridden(uiSourceCode);
   }
 
   async setupAndStartLocalOverrides(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<boolean> {
-    if (!this.isUISourceCodeOverridable(uiSourceCode)) {
+    if (!this.#canPersistUISourceCodeAsOverride(uiSourceCode)) {
       return false;
     }
     // No overrides folder, set it up

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -545,6 +545,7 @@ class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntr
   /** The resolved `this` of the current call frame */
   readonly #thisObject: SDK.RemoteObject.RemoteObject|null;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #object?: SDK.RemoteObject.RemoteObject;
 
   constructor(scope: SDK.DebuggerModel.ScopeChainEntry, thisObject: SDK.RemoteObject.RemoteObject|null,
               debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
@@ -574,7 +575,10 @@ class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntr
   }
 
   object(): SDK.RemoteObject.RemoteObject {
-    return resolveScopeInObject(this.#debuggerScope, this.#debuggerWorkspaceBinding);
+    if (!this.#object) {
+      this.#object = resolveScopeInObject(this.#debuggerScope, this.#debuggerWorkspaceBinding);
+    }
+    return this.#object;
   }
 
   description(): string {
@@ -599,6 +603,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
   private readonly scope: SDK.DebuggerModel.ScopeChainEntry;
   private readonly object: SDK.RemoteObject.RemoteObject;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #allPropertiesPromise?: Promise<SDK.RemoteObject.GetPropertiesResult>;
+  #cachedWithPreview = false;
 
   constructor(scope: SDK.DebuggerModel.ScopeChainEntry,
               debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
@@ -650,6 +656,18 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
 
   override async getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean):
       Promise<SDK.RemoteObject.GetPropertiesResult> {
+    if (accessorPropertiesOnly) {
+      return await this.#resolveAllProperties(true, generatePreview);
+    }
+    if (!this.#allPropertiesPromise || (generatePreview && !this.#cachedWithPreview)) {
+      this.#cachedWithPreview = generatePreview;
+      this.#allPropertiesPromise = this.#resolveAllProperties(false, generatePreview);
+    }
+    return await this.#allPropertiesPromise;
+  }
+
+  async #resolveAllProperties(accessorPropertiesOnly: boolean,
+                              generatePreview: boolean): Promise<SDK.RemoteObject.GetPropertiesResult> {
     const allProperties = await this.object.getAllProperties(accessorPropertiesOnly, generatePreview);
     const {variableMapping} = await resolveDebuggerScope(this.scope, this.#debuggerWorkspaceBinding);
 
@@ -664,6 +682,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
 
   override async setPropertyValue(argumentName: string|Protocol.Runtime.CallArgument, value: string):
       Promise<string|undefined> {
+    this.#allPropertiesPromise = undefined;
+    this.#cachedWithPreview = false;
     const {variableMapping} = await resolveDebuggerScope(this.scope, this.#debuggerWorkspaceBinding);
 
     let name;
@@ -684,6 +704,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
   }
 
   override async deleteProperty(name: Protocol.Runtime.CallArgument): Promise<string|undefined> {
+    this.#allPropertiesPromise = undefined;
+    this.#cachedWithPreview = false;
     return await this.object.deleteProperty(name);
   }
 

package/front_end/models/source_map_scopes/ScopeChainModel.ts

@@ -21,6 +21,9 @@ import {resolveScopeChain} from './NamesResolver.js';
  * This class tracks all that and sends events with the latest scope chain for a specific call frame.
  */
 export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  static readonly #cachedScopeChainByCallFrame =
+      new WeakMap<SDK.DebuggerModel.CallFrame, Promise<SDK.DebuggerModel.ScopeChainEntry[]>>();
+
   readonly #callFrame: SDK.DebuggerModel.CallFrame;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
 
@@ -53,13 +56,29 @@ export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     this.listeners?.clear();
   }
 
+  static resolveScopeChain(callFrame: SDK.DebuggerModel.CallFrame,
+                           debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
+      Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
+    let cachedPromise = ScopeChainModel.#cachedScopeChainByCallFrame.get(callFrame);
+    if (!cachedPromise) {
+      cachedPromise = resolveScopeChain(callFrame, debuggerWorkspaceBinding);
+      ScopeChainModel.#cachedScopeChainByCallFrame.set(callFrame, cachedPromise);
+    }
+    return cachedPromise;
+  }
+
+  resolveScopeChain(): Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
+    return ScopeChainModel.resolveScopeChain(this.#callFrame, this.#debuggerWorkspaceBinding);
+  }
+
   async #update(): Promise<void> {
-    const scopeChain = await resolveScopeChain(this.#callFrame, this.#debuggerWorkspaceBinding);
+    const scopeChain = await this.resolveScopeChain();
     this.dispatchEventToListeners(Events.SCOPE_CHAIN_UPDATED, new ScopeChain(scopeChain));
   }
 
   #debugInfoAttached(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
     if (event.data === this.#callFrame.script) {
+      ScopeChainModel.#cachedScopeChainByCallFrame.delete(this.#callFrame);
       void this.#throttler.schedule(this.#boundUpdate);
     }
   }
@@ -67,6 +86,7 @@ export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   #sourceMapChanged(event: Common.EventTarget
                         .EventTargetEvent<{client: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap}>): void {
     if (event.data.client === this.#callFrame.script) {
+      ScopeChainModel.#cachedScopeChainByCallFrame.delete(this.#callFrame);
       void this.#throttler.schedule(this.#boundUpdate);
     }
   }

package/front_end/panels/ai_assistance/ai_assistance-meta.ts

@@ -35,22 +35,18 @@ const UIStrings = {
    * the current context.
    */
   debugWithAi: 'Debug with AI',
-  /**
-   * @description The title of the Gemini panel.
-   */
-  gemini: 'Gemini',
   /**
    * @description The title of the command menu action for showing the Gemini panel.
    */
-  showGemini: 'Show Gemini',
+  showGemini: 'Show `Gemini`',
   /**
    * @description The setting title to enable the Gemini via the settings tab.
    */
-  enableGemini: 'Enable Gemini',
+  enableGemini: 'Enable `Gemini`',
   /**
    * @description Text of a context menu item to redirect to the Gemini panel with the current context.
    */
-  debugWithGemini: 'Debug with Gemini',
+  debugWithGemini: 'Debug with `Gemini`',
 } as const;
 
 const str_ = i18n.i18n.registerUIStrings('panels/ai_assistance/ai_assistance-meta.ts', UIStrings);
@@ -108,7 +104,8 @@ UI.ViewManager.registerViewExtension({
   location: UI.ViewManager.ViewLocationValues.DRAWER_VIEW,
   id: 'freestyler',
   commandPrompt: i18nAiBrandedString(UIStrings.showGemini, UIStrings.showAiAssistance),
-  title: i18nAiBrandedString(UIStrings.gemini, UIStrings.aiAssistance),
+  title: () => Root.Runtime.hostConfig.devToolsGeminiRebranding?.enabled ? i18n.i18n.lockedString('Gemini') :
+                                                                           i18nString(UIStrings.aiAssistance),
   order: 10,
   persistence: UI.ViewManager.ViewPersistence.CLOSEABLE,
   hasToolbar: false,