chrome-devtools-frontend 1.0.1555430 → 1.0.1558690

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -496,7 +496,7 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     const modelData =
         this.#debuggerModelToData.get(target.model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel);
     if (modelData) {
-      modelData.translateRawFramesStep(rawFrames, translatedFrames);
+      await modelData.translateRawFramesStep(rawFrames, translatedFrames);
       return;
     }
 
@@ -609,10 +609,10 @@ class ModelData {
     return scope;
   }
 
-  translateRawFramesStep(
+  async translateRawFramesStep(
       rawFrames: StackTraceImpl.Trie.RawFrame[],
-      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): void {
-    if (!this.compilerMapping.translateRawFramesStep(rawFrames, translatedFrames)) {
+      translatedFrames: Awaited<ReturnType<StackTraceImpl.StackTraceModel.TranslateRawFrames>>): Promise<void> {
+    if (!await this.compilerMapping.translateRawFramesStep(rawFrames, translatedFrames)) {
       this.#defaultTranslateRawFramesStep(rawFrames, translatedFrames);
     }
   }

package/front_end/models/greendev/Prototypes.ts

@@ -0,0 +1,56 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
+
+let instance: Prototypes|null = null;
+
+export interface GreenDevSettings {
+  inDevToolsFloaty: Common.Settings.Setting<boolean>;
+  inlineWidgets: Common.Settings.Setting<boolean>;
+  artifactViewer: Common.Settings.Setting<boolean>;
+  aiAnnotations: Common.Settings.Setting<boolean>;
+}
+
+export class Prototypes {
+  private constructor() {
+  }
+
+  static instance(): Prototypes {
+    if (instance) {
+      return instance;
+    }
+    instance = new Prototypes();
+    return instance;
+  }
+
+  /**
+   * Returns true if the specific setting is turned on AND the GreenDev flag is enabled
+   */
+  isEnabled(setting: keyof GreenDevSettings): boolean {
+    const greendevFlagEnabled = Boolean(Root.Runtime.hostConfig.devToolsGreenDevUi?.enabled);
+
+    return greendevFlagEnabled && this.settings()[setting].get();
+  }
+
+  settings(): Readonly<GreenDevSettings> {
+    const settings = Common.Settings.Settings.instance();
+    const inDevToolsFloaty =
+        settings.createSetting('greendev-in-devtools-floaty-enabled', false, Common.Settings.SettingStorageType.LOCAL);
+
+    const inlineWidgets =
+        settings.createSetting('greendev-inline-widgets-enabled', false, Common.Settings.SettingStorageType.LOCAL);
+
+    const aiAnnotations = settings.createSetting(
+        'greendev-ai-annotations-enabled',
+        false,
+        Common.Settings.SettingStorageType.LOCAL,
+    );
+
+    const artifactViewer =
+        settings.createSetting('greendev-artifact-viewer-enabled', false, Common.Settings.SettingStorageType.LOCAL);
+    return {inDevToolsFloaty, inlineWidgets, aiAnnotations, artifactViewer};
+  }
+}

package/front_end/models/greendev/README.md

@@ -0,0 +1,5 @@
+# GreenDev Model
+
+As part of GreenDev we are building a bunch of prototypes into DevTools to user test. This model holds which prototypes are enabled for a given user.
+
+The settings is only stored in local storage, and not synced across devices or persisted in anyway beyond that.

package/front_end/models/greendev/greendev.ts

@@ -0,0 +1,5 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export * from './Prototypes.js';

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -8896,11 +8896,11 @@ export const NativeFunctions = [
   },
   {
     name: "texElementImage2D",
-    signatures: [["target","level","internalformat","format","type","element"],["target","level","internalformat","width","height","format","type","element"]]
+    signatures: [["target","level","internalformat","format","type","element"],["target","level","internalformat","width","height","format","type","element"],["target","level","internalformat","sx","sy","swidth","sheight","format","type","element"],["target","level","internalformat","sx","sy","swidth","sheight","width","height","format","type","element"]]
   },
   {
     name: "texElement2D",
-    signatures: [["target","level","internalformat","format","type","element"],["target","level","internalformat","width","height","format","type","element"]]
+    signatures: [["target","level","internalformat","format","type","element"],["target","level","internalformat","width","height","format","type","element"],["target","level","internalformat","sx","sy","swidth","sheight","format","type","element"],["target","level","internalformat","sx","sy","swidth","sheight","width","height","format","type","element"]]
   },
   {
     name: "drawingBufferStorage",

package/front_end/models/stack_trace/StackTraceImpl.ts

@@ -105,9 +105,11 @@ export class DebuggableFragmentImpl implements StackTrace.StackTrace.DebuggableF
 
     let index = 0;
     for (const node of this.fragment.node.getCallStack()) {
-      for (const frame of node.frames) {
-        // Each inlined frame gets the same DebugerModel.CallFrame for debugging.
-        frames.push(new DebuggableFrameImpl(frame, this.callFrames[index]));
+      for (const [inlineIdx, frame] of node.frames.entries()) {
+        // Create virtual frames for inlined frames.
+        const sdkFrame = inlineIdx === 0 ? this.callFrames[index] :
+                                           this.callFrames[index].createVirtualCallFrame(inlineIdx, frame.name ?? '');
+        frames.push(new DebuggableFrameImpl(frame, sdkFrame));
       }
       index++;
     }

package/front_end/models/stack_trace/StackTraceModel.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Common from '../../core/common/common.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 
@@ -32,6 +33,7 @@ export type TranslateRawFrames = (frames: readonly RawFrame[], target: SDK.Targe
  */
 export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
   readonly #trie = new Trie();
+  readonly #mutex = new Common.Mutex.Mutex();
 
   /** @returns the {@link StackTraceModel} for the target, or the model for the primaryPageTarget when passing null/undefined */
   static #modelForTarget(target: SDK.Target.Target|null|undefined): StackTraceModel {
@@ -45,7 +47,7 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
   async createFromProtocolRuntime(stackTrace: Protocol.Runtime.StackTrace, rawFramesToUIFrames: TranslateRawFrames):
       Promise<StackTrace.StackTrace.StackTrace> {
     const [syncFragment, asyncFragments] = await Promise.all([
-      this.#createSyncFragment(stackTrace, rawFramesToUIFrames),
+      this.#createFragment(stackTrace.callFrames, rawFramesToUIFrames),
       this.#createAsyncFragments(stackTrace, rawFramesToUIFrames),
     ]);
 
@@ -65,53 +67,51 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
 
   /** Trigger re-translation of all fragments with the provide script in their call stack */
   async scriptInfoChanged(script: SDK.Script.Script, translateRawFrames: TranslateRawFrames): Promise<void> {
-    const translatePromises: Array<Promise<unknown>> = [];
-    let stackTracesToUpdate = new Set<AnyStackTraceImpl>();
-
-    for (const fragment of this.#affectedFragments(script)) {
-      // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
-      // is re-translated as a side-effect.
-      // We just need to remember the stack traces of the skipped over fragments, so we can send the
-      // UPDATED event also to them.
-      if (fragment.node.children.length === 0) {
-        translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
+    const release = await this.#mutex.acquire();
+    try {
+      const translatePromises: Array<Promise<unknown>> = [];
+      let stackTracesToUpdate = new Set<AnyStackTraceImpl>();
+
+      for (const fragment of this.#affectedFragments(script)) {
+        // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
+        // is re-translated as a side-effect.
+        // We just need to remember the stack traces of the skipped over fragments, so we can send the
+        // UPDATED event also to them.
+        if (fragment.node.children.length === 0) {
+          translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
+        }
+        stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
       }
-      stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
-    }
 
-    await Promise.all(translatePromises);
+      await Promise.all(translatePromises);
 
-    for (const stackTrace of stackTracesToUpdate) {
-      stackTrace.dispatchEventToListeners(StackTrace.StackTrace.Events.UPDATED);
+      for (const stackTrace of stackTracesToUpdate) {
+        stackTrace.dispatchEventToListeners(StackTrace.StackTrace.Events.UPDATED);
+      }
+    } finally {
+      release();
     }
   }
 
-  async #createSyncFragment(stackTrace: Protocol.Runtime.StackTrace, rawFramesToUIFrames: TranslateRawFrames):
-      Promise<FragmentImpl> {
-    const fragment = this.#createFragment(stackTrace.callFrames);
-    await this.#translateFragment(fragment, rawFramesToUIFrames);
-    return fragment;
-  }
-
   async #createDebuggableFragment(
       pausedDetails: SDK.DebuggerModel.DebuggerPausedDetails,
       rawFramesToUIFrames: TranslateRawFrames): Promise<DebuggableFragmentImpl> {
-    const fragment = this.#createFragment(pausedDetails.callFrames.map(frame => ({
-                                                                         scriptId: frame.script.scriptId,
-                                                                         url: frame.script.sourceURL,
-                                                                         functionName: frame.functionName,
-                                                                         lineNumber: frame.location().lineNumber,
-                                                                         columnNumber: frame.location().columnNumber,
-                                                                       })));
-    await this.#translateFragment(fragment, rawFramesToUIFrames);
+    const fragment = await this.#createFragment(
+        pausedDetails.callFrames.map(frame => ({
+                                       scriptId: frame.script.scriptId,
+                                       url: frame.script.sourceURL,
+                                       functionName: frame.functionName,
+                                       lineNumber: frame.location().lineNumber,
+                                       columnNumber: frame.location().columnNumber,
+                                     })),
+        rawFramesToUIFrames);
     return new DebuggableFragmentImpl(fragment, pausedDetails.callFrames);
   }
 
   async #createAsyncFragments(
       stackTraceOrPausedEvent: Protocol.Runtime.StackTrace|SDK.DebuggerModel.DebuggerPausedDetails,
       rawFramesToUIFrames: TranslateRawFrames): Promise<AsyncFragmentImpl[]> {
-    const asyncFragments: AsyncFragmentImpl[] = [];
-    const translatePromises: Array<Promise<unknown>> = [];
+    const asyncFragments: Array<Promise<AsyncFragmentImpl>> = [];
 
     const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
     if (debuggerModel) {
@@ -122,18 +122,31 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
           continue;
         }
         const model = StackTraceModel.#modelForTarget(target);
-        const fragment = model.#createFragment(asyncStackTrace.callFrames);
-        translatePromises.push(model.#translateFragment(fragment, rawFramesToUIFrames));
-        asyncFragments.push(new AsyncFragmentImpl(asyncStackTrace.description ?? '', fragment));
+        const asyncFragmentPromise =
+            model.#createFragment(asyncStackTrace.callFrames, rawFramesToUIFrames)
+                .then(fragment => new AsyncFragmentImpl(asyncStackTrace.description ?? '', fragment));
+        asyncFragments.push(asyncFragmentPromise);
       }
     }
 
-    await Promise.all(translatePromises);
-    return asyncFragments;
+    return await Promise.all(asyncFragments);
   }
 
-  #createFragment(frames: RawFrame[]): FragmentImpl {
-    return FragmentImpl.getOrCreate(this.#trie.insert(frames));
+  async #createFragment(frames: RawFrame[], rawFramesToUIFrames: TranslateRawFrames): Promise<FragmentImpl> {
+    const release = await this.#mutex.acquire();
+    try {
+      const node = this.#trie.insert(frames);
+      const requiresTranslation = !Boolean(node.fragment);
+      const fragment = FragmentImpl.getOrCreate(node);
+
+      if (requiresTranslation) {
+        await this.#translateFragment(fragment, rawFramesToUIFrames);
+      }
+
+      return fragment;
+    } finally {
+      release();
+    }
   }
 
   async #translateFragment(fragment: FragmentImpl, rawFramesToUIFrames: TranslateRawFrames): Promise<void> {

package/front_end/models/trace/EventsSerializer.ts

@@ -20,9 +20,15 @@ export class EventsSerializer {
     }
 
     const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
+    const isSynthetic = Types.Events.isSyntheticBased(event);
+    const index = rawEvents.indexOf(isSynthetic ? event.rawSourceEvent : event);
+    if (index === -1) {
+      throw new Error(`Unknown trace event: ${event.name}`);
+    }
+
     const key: Types.File.SyntheticEventKey|Types.File.RawEventKey = Types.Events.isSyntheticBased(event) ?
-        `${Types.File.EventKeyType.SYNTHETIC_EVENT}-${rawEvents.indexOf(event.rawSourceEvent)}` :
-        `${Types.File.EventKeyType.RAW_EVENT}-${rawEvents.indexOf(event)}`;
+        `${Types.File.EventKeyType.SYNTHETIC_EVENT}-${index}` :
+        `${Types.File.EventKeyType.RAW_EVENT}-${index}`;
     if (key.length < 3) {
       return null;
     }

package/front_end/models/trace/extras/TraceTree.ts

@@ -493,8 +493,10 @@ export class BottomUpRootNode extends Node {
         node.totalTime += totalTimeById.get(id) || 0;
         totalTimeById.delete(id);
       }
-      // TODO: this may be wrong. See the skipped test in TraceTree.test.ts.
-      if (firstNodeStack.length) {
+
+      // An item on this stack means that this current node has a caller. Therefore,
+      // in a bottom-up view it has children.
+      if (idStack.length > 0) {
         node.setHasChildren(true);
       }
     }

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

@@ -443,7 +443,7 @@ async function buildLayoutShiftsClusters(): Promise<void> {
     }
 
     let largestScore = 0;
-    let worstShiftEvent: Types.Events.Event|null = null;
+    let worstShiftEvent: Types.Events.SyntheticLayoutShift|null = null;
 
     for (const shift of cluster.events) {
       weightedScore += shift.args.data ? shift.args.data.weighted_score_delta : 0;
@@ -504,7 +504,7 @@ async function buildLayoutShiftsClusters(): Promise<void> {
     // Update the cluster's worst layout shift.
     if (worstShiftEvent) {
       cluster.worstShiftEvent = worstShiftEvent;
-      cluster.rawSourceEvent = worstShiftEvent;
+      cluster.rawSourceEvent = worstShiftEvent.rawSourceEvent;
     }
 
     // layout shifts are already sorted by time ascending.

package/front_end/models/trace/insights/LCPDiscovery.ts

@@ -129,8 +129,6 @@ export function generateInsight(
   }
 
   const initiatorUrl = lcpRequest.args.data.initiator?.url;
-  // TODO(b/372319476): Explore using trace event HTMLDocumentParser::FetchQueuedPreloads to determine if the request
-  // is discovered by the preload scanner.
   const initiatedByMainDoc =
       lcpRequest?.args.data.initiator?.type === 'parser' && docRequest.args.data.url === initiatorUrl;
   const imgPreloadedOrFoundInHTML = lcpRequest?.args.data.isLinkPreload || initiatedByMainDoc;

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

@@ -1078,7 +1078,6 @@ export interface ResourceSendRequest extends Instant {
       resourceType?: Protocol.Network.ResourceType,
       /** Added Feb 2024. https://crrev.com/c/5297615 */
       fetchPriorityHint?: FetchPriorityHint,
-      // TODO(crbug.com/1457985): change requestMethod to enum when confirm in the backend code.
       requestMethod?: string,
       renderBlocking?: RenderBlocking,
       initiator?: Initiator,