chrome-devtools-frontend 1.0.1667564 → 1.0.1669021

package/front_end/models/ai_assistance/BuiltInAi.ts

@@ -6,8 +6,6 @@ import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as Root from '../../core/root/root.js';
 
-let builtInAiInstance: BuiltInAi|undefined;
-
 export interface LanguageModel {
   promptStreaming: (arg0: string, opts?: {
     signal?: AbortSignal,
@@ -33,10 +31,11 @@ export class BuiltInAi extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #currentlyCreatingSession = false;
 
   static instance(): BuiltInAi {
-    if (builtInAiInstance === undefined) {
-      builtInAiInstance = new BuiltInAi();
+    if (!Root.DevToolsContext.globalInstance().has(BuiltInAi)) {
+      Root.DevToolsContext.globalInstance().set(BuiltInAi, new BuiltInAi());
     }
-    return builtInAiInstance;
+
+    return Root.DevToolsContext.globalInstance().get(BuiltInAi);
   }
 
   constructor() {
@@ -107,6 +106,12 @@ export class BuiltInAi extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   }
 
   #isGpuAvailable(): boolean {
+    // In node-based API tests, there is no global `document` available. Since this
+    // class is instantiated during Universe bootstrapping, we need to guard against
+    // using document when not in the browser.
+    if (typeof document === 'undefined') {
+      return false;
+    }
     const canvas = document.createElement('canvas');
     try {
       const webgl = canvas.getContext('webgl');
@@ -197,7 +202,7 @@ Your instructions are as follows:
   }
 
   static removeInstance(): void {
-    builtInAiInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(BuiltInAi);
   }
 
   async * getConsoleInsight(prompt: string, abortController: AbortController): AsyncGenerator<string> {

package/front_end/models/ai_assistance/ChangeManager.ts

@@ -25,13 +25,15 @@ function formatStyles(styles: Record<string, string>, indent = 2): string {
  * primarily for stylesheet generation based on all changes.
  */
 export class ChangeManager {
+  readonly #targetManager: SDK.TargetManager.TargetManager;
   readonly #stylesheetMutex = new Common.Mutex.Mutex();
   readonly #cssModelToStylesheetId =
       new Map<SDK.CSSModel.CSSModel, Map<Protocol.Page.FrameId, Protocol.DOM.StyleSheetId>>();
   readonly #stylesheetChanges = new Map<Protocol.DOM.StyleSheetId, Change[]>();
 
   constructor(targetManager: SDK.TargetManager.TargetManager = SDK.TargetManager.TargetManager.instance()) {
-    targetManager.addModelListener(
+    this.#targetManager = targetManager;
+    this.#targetManager.addModelListener(
         SDK.ResourceTreeModel.ResourceTreeModel,
         SDK.ResourceTreeModel.Events.PrimaryPageChanged,
         this.clear,
@@ -39,6 +41,20 @@ export class ChangeManager {
     );
   }
 
+  dispose(): void {
+    this.#targetManager.removeModelListener(
+        SDK.ResourceTreeModel.ResourceTreeModel,
+        SDK.ResourceTreeModel.Events.PrimaryPageChanged,
+        this.clear,
+        this,
+    );
+    for (const cssModel of this.#cssModelToStylesheetId.keys()) {
+      cssModel.removeEventListener(SDK.CSSModel.Events.ModelDisposed, this.#onCssModelDisposed, this);
+    }
+    this.#cssModelToStylesheetId.clear();
+    this.#stylesheetChanges.clear();
+  }
+
   async clear(): Promise<void> {
     const models = Array.from(this.#cssModelToStylesheetId.keys());
     const results = await Promise.allSettled(models.map(async model => {

package/front_end/models/ai_assistance/StorageItem.ts

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+export const EMPTY_ORIGIN = '';
+
 export class StorageItem {
   constructor(
       /**
@@ -10,12 +12,20 @@ export class StorageItem {
        */
       readonly primaryTargetOrigin: string,
       /**
-       * The origin of the selected storage or cookie item (if any).
-       * If no item is selected, this is the same as primaryTargetOrigin.
+       * The origin of the selected storage or cookie item.
+       * If empty (''), this represents a generic category-level context (e.g., all Local Storage or all Cookies).
        */
-      readonly origin: string,
+      readonly origin: string = EMPTY_ORIGIN,
   ) {
   }
+
+  get isGenericContext(): boolean {
+    return this.origin === EMPTY_ORIGIN;
+  }
+
+  static createGenericContext(primaryTargetOrigin: string, ..._args: unknown[]): StorageItem {
+    return new StorageItem(primaryTargetOrigin, EMPTY_ORIGIN);
+  }
 }
 
 export class DOMStorageItem extends StorageItem {
@@ -23,18 +33,29 @@ export class DOMStorageItem extends StorageItem {
       primaryTargetOrigin: string,
       origin: string,
       /** The storage key partition identifier used by the browser storage engine. */
-      readonly storageKey: string,
+      readonly storageKey: string|undefined,
       /** The sub-category of DOM storage: 'localStorage' or 'sessionStorage'. */
-      readonly type: string,
+      readonly type: 'localStorage'|'sessionStorage',
       /** The optional specific key of the selected item in this storage partition. */
       readonly key?: string,
   ) {
     super(primaryTargetOrigin, origin);
   }
+
+  static override createGenericContext(
+      primaryTargetOrigin: string,
+      type: 'localStorage'|'sessionStorage',
+      ): DOMStorageItem {
+    return new DOMStorageItem(primaryTargetOrigin, EMPTY_ORIGIN, undefined, type);
+  }
 }
 
 export class CookieItem extends StorageItem {
   constructor(primaryTargetOrigin: string, origin: string, readonly name?: string) {
     super(primaryTargetOrigin, origin);
   }
+
+  static override createGenericContext(primaryTargetOrigin: string): CookieItem {
+    return new CookieItem(primaryTargetOrigin, EMPTY_ORIGIN);
+  }
 }

package/front_end/models/ai_code_completion/AiCodeCompletion.ts

@@ -145,18 +145,15 @@ export class AiCodeCompletion {
   #renderingTimeout?: number;
   #aidaRequestCache?: CachedRequest;
   #lastEmptyResponseText?: string;
-  // TODO(b/445394511): Remove panel from the class
-  #panel: ContextFlavor;
   #callbacks?: Callbacks;
 
   readonly #sessionId: string = crypto.randomUUID();
   readonly #aidaClient: Host.AidaClient.AidaClient;
   readonly #serverSideLoggingEnabled: boolean;
 
-  constructor(opts: AgentOptions, panel: ContextFlavor, callbacks?: Callbacks, stopSequences?: string[]) {
+  constructor(opts: AgentOptions, callbacks?: Callbacks, stopSequences?: string[]) {
     this.#aidaClient = opts.aidaClient;
     this.#serverSideLoggingEnabled = opts.serverSideLoggingEnabled ?? false;
-    this.#panel = panel;
     this.#stopSequences = stopSequences ?? [];
     this.#callbacks = callbacks;
   }
@@ -172,15 +169,7 @@ export class AiCodeCompletion {
     // As a temporary fix for b/441221870 we are prepending a newline for each prefix.
     prefix = '\n' + prefix;
 
-    let additionalContextFiles = additionalFiles;
-    if (!additionalContextFiles) {
-      additionalContextFiles = this.#panel === ContextFlavor.CONSOLE ? [{
-        path: 'devtools-console-context.js',
-        content: consoleAdditionalContextFileContent,
-        included_reason: Host.AidaClient.Reason.RELATED_FILE,
-      }] :
-                                                                       undefined;
-    }
+    const additionalContextFiles = additionalFiles;
     return {
       client: Host.AidaClient.CLIENT_NAME,
       prefix,
@@ -384,9 +373,3 @@ export class AiCodeCompletion {
     return Boolean(aidaAvailability.enabled && AiCodeCompletion.isAiCodeCompletionStylesAvailable());
   }
 }
-
-export const enum ContextFlavor {
-  CONSOLE = 'console',  // generated code can contain console specific APIs like `$0`.
-  SOURCES = 'sources',
-  STYLES = 'styles',
-}

package/front_end/models/ai_code_generation/AiCodeGeneration.ts

@@ -158,9 +158,8 @@ export class AiCodeGeneration {
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeGenerationSuggestionAccepted);
   }
 
-  async generateCode(
-      prompt: string, preamble: string, inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage,
-      options?: {signal?: AbortSignal}): Promise<Host.AidaClient.GenerateCodeResponse|null> {
+  async generateCode(prompt: string, preamble: string, inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage,
+                     options?: {signal?: AbortSignal}): Promise<Host.AidaClient.GenerateCodeResponse> {
     const request = this.#buildRequest(prompt, preamble, inferenceLanguage);
     const response = await this.#aidaClient.generateCode(request, options);
 

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -117,11 +117,6 @@ export const NativeFunctions = [
     signatures: [["id"]],
     receivers: ["Clients","BackgroundFetchManager"]
   },
-  {
-    name: "get",
-    signatures: [["entry"]],
-    receivers: ["RouteMap"]
-  },
   {
     name: "set",
     signatures: [["v"]],
@@ -2003,6 +1998,11 @@ export const NativeFunctions = [
     signatures: [["start","end"]],
     receivers: ["SourceBuffer"]
   },
+  {
+    name: "remove",
+    signatures: [["slot"]],
+    receivers: ["GPUResourceTable"]
+  },
   {
     name: "remove",
     signatures: [["manifest_ids"]],
@@ -3302,6 +3302,11 @@ export const NativeFunctions = [
     signatures: [["response"]],
     receivers: ["MediaKeySession"]
   },
+  {
+    name: "update",
+    signatures: [["slot","resource"]],
+    receivers: ["GPUResourceTable"]
+  },
   {
     name: "createObjectStore",
     signatures: [["name","?options"]]
@@ -6685,6 +6690,14 @@ export const NativeFunctions = [
     name: "writeTimestamp",
     signatures: [["querySet","queryIndex"]]
   },
+  {
+    name: "setResourceTable",
+    signatures: [["table"]]
+  },
+  {
+    name: "createResourceTable",
+    signatures: [["descriptor"]]
+  },
   {
     name: "GPUInternalError",
     signatures: [["message"]]
@@ -6713,6 +6726,10 @@ export const NativeFunctions = [
     name: "multiDrawIndexedIndirect",
     signatures: [["indirectBuffer","indirectOffset","maxDrawCount","?drawCountBuffer","?drawCountBufferOffset"]]
   },
+  {
+    name: "insert",
+    signatures: [["resource"]]
+  },
   {
     name: "GPUUncapturedErrorEvent",
     signatures: [["type","gpuUncapturedErrorEventInitDict"]]
@@ -8469,10 +8486,6 @@ export const NativeFunctions = [
     name: "removeProcessingInstruction",
     signatures: [["pi"]]
   },
-  {
-    name: "RouteEvent",
-    signatures: [["type"]]
-  },
   {
     name: "ResizeObserver",
     signatures: [["callback"]]

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -187,21 +187,21 @@ const enum Punctuation {
   EQUALS = 'equals',
 }
 
-const resolveDebuggerScope = async(
-    scope: SDK.DebuggerModel.ScopeChainEntry,
-    debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-    Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => {
-      if (!scope.callFrame()
-               .debuggerModel.target()
-               .targetManager()
-               .settings.moduleSetting('js-source-maps-enabled')
-               .get()) {
-        return {variableMapping: new Map(), thisMapping: null};
-      }
-      const script = scope.callFrame().script;
-      const scopeChain = await findScopeChainForDebuggerScope(scope);
-      return await resolveScope(script, scopeChain, debuggerWorkspaceBinding);
-    };
+const resolveDebuggerScope =
+    async(scope: SDK.DebuggerModel.ScopeChainEntry,
+          debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
+        Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => {
+          if (!scope.callFrame()
+                   .debuggerModel.target()
+                   .targetManager()
+                   .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
+                   .get()) {
+            return {variableMapping: new Map(), thisMapping: null};
+          }
+          const script = scope.callFrame().script;
+          const scopeChain = await findScopeChainForDebuggerScope(scope);
+          return await resolveScope(script, scopeChain, debuggerWorkspaceBinding);
+        };
 
 const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.FormatterWorkerPool.ScopeTreeNode[],
                            debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
@@ -400,7 +400,10 @@ export const allVariablesInCallFrame = async(
     callFrame: SDK.DebuggerModel.CallFrame,
     debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
     Promise<Map<string, string|null>> => {
-      if (!callFrame.debuggerModel.target().targetManager().settings.moduleSetting('js-source-maps-enabled').get()) {
+      if (!callFrame.debuggerModel.target()
+               .targetManager()
+               .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
+               .get()) {
         return new Map<string, string|null>();
       }
       const cachedMap = cachedMapByCallFrame.get(callFrame);
@@ -443,7 +446,10 @@ export const allVariablesAtPosition =
           if (!script) {
             return reverseMapping;
           }
-          if (!script.debuggerModel.target().targetManager().settings.moduleSetting('js-source-maps-enabled').get()) {
+          if (!script.debuggerModel.target()
+                   .targetManager()
+                   .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
+                   .get()) {
             return reverseMapping;
           }
 

package/front_end/models/trace/handlers/RendererHandler.ts

@@ -305,13 +305,23 @@ export function sanitizeThreads(processes: Map<Types.Events.ProcessID, RendererP
 export function buildHierarchy(
     processes: Map<Types.Events.ProcessID, RendererProcess>,
     options?: {filter: {has: (name: Types.Events.Name) => boolean}}): void {
+  // Ensure threads that only contain V8 CPU profiler samples (such as WebAssembly
+  // background execution threads) are registered in their process before we iterate.
+  // These threads do not receive standard renderer trace events, so their RendererThread
+  // objects must be initialized here so SamplesIntegrator can inject profile calls.
   const samplesData = samplesHandlerData();
+  for (const [pid, profilesByThread] of samplesData.profilesInProcess) {
+    const process = processes.get(pid);
+    if (!process) {
+      continue;
+    }
+    for (const [tid] of profilesByThread) {
+      getOrCreateRendererThread(process, tid);
+    }
+  }
+
   for (const [pid, process] of processes) {
     for (const [tid, thread] of process.threads) {
-      if (!thread.entries.length) {
-        thread.tree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
-        continue;
-      }
       // Step 1. Massage the data.
       Helpers.Trace.sortTraceEventsInPlace(thread.entries);
       // Step 2. Inject profile calls from samples
@@ -333,6 +343,12 @@ export function buildHierarchy(
           }
         }
       }
+
+      if (!thread.entries.length) {
+        thread.tree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
+        continue;
+      }
+
       // Step 3. Build the tree.
       const treeData = Helpers.TreeHelpers.treify(thread.entries, options);
       thread.tree = treeData.tree;

package/front_end/models/trace/types/File.ts

@@ -211,6 +211,7 @@ export interface PersistedTraceVisualConfig {
  * on load.
  */
 export interface MetaData {
+  title?: string;
   source?: 'DevTools';
   startTime?: string;
   emulatedDeviceTitle?: string;

package/front_end/models/workspace/UISourceCode.ts

@@ -47,7 +47,6 @@ export class UISourceCode extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   #contentEncoded: boolean|undefined;
   #isKnownThirdParty = false;
   #isUnconditionallyIgnoreListed = false;
-  #containsAiChanges = false;
 
   constructor(project: Project, url: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType) {
     super();
@@ -343,7 +342,6 @@ export class UISourceCode extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   #resetWorkingCopy(): void {
     this.#workingCopy = null;
     this.#workingCopyGetter = null;
-    this.setContainsAiChanges(false);
   }
 
   setWorkingCopy(newWorkingCopy: string): void {
@@ -352,14 +350,6 @@ export class UISourceCode extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     this.#workingCopyChanged();
   }
 
-  setContainsAiChanges(containsAiChanges: boolean): void {
-    this.#containsAiChanges = containsAiChanges;
-  }
-
-  containsAiChanges(): boolean {
-    return this.#containsAiChanges;
-  }
-
   setContent(content: string, isBase64: boolean): void {
     this.#contentEncoded = isBase64;
     if (this.#project.canSetFileContent()) {