chrome-devtools-frontend 1.0.1661063 → 1.0.1662965

package/front_end/models/har/Log.ts

@@ -9,7 +9,7 @@
 // See https://bugs.webkit.org/show_bug.cgi?id=58127 for details.
 
 import * as Common from '../../core/common/common.js';
-import type * as Platform from '../../core/platform/platform.js';
+import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 
@@ -33,7 +33,8 @@ export class Log {
   }
 
   private creator(): Creator {
-    const webKitVersion = /AppleWebKit\/([^ ]+)/.exec(window.navigator.userAgent);
+    const userAgent = Platform.HostRuntime.HOST_RUNTIME.getUserAgent();
+    const webKitVersion = /AppleWebKit\/([^ ]+)/.exec(userAgent);
 
     return {name: 'WebInspector', version: webKitVersion ? webKitVersion[1] : 'n/a'};
   }

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -11,6 +11,7 @@ import type * as HeapSnapshotModel from './HeapSnapshotModel.js';
 
 export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<HeapSnapshotWorkerProxy.EventTypes> {
   readonly eventHandler: (arg0: string, arg1: string) => void;
+  #console: Common.Console.Console;
   nextObjectId = 1;
   nextCallId = 1;
   callbacks = new Map<number, (...args: any[]) => void>();
@@ -19,9 +20,14 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
   interval?: number;
   readonly workerUrl?: string;
 
-  constructor(eventHandler: (arg0: string, arg1: string) => void, workerUrl?: string) {
+  constructor(
+      eventHandler: (arg0: string, arg1: string) => void,
+      console: Common.Console.Console,
+      workerUrl?: string,
+  ) {
     super();
     this.eventHandler = eventHandler;
+    this.#console = console;
     this.workerUrl = workerUrl;
     this.worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(
         workerUrl ?? import.meta.resolve('../../entrypoints/heap_snapshot_worker/heap_snapshot_worker-entrypoint.js'),
@@ -29,6 +35,10 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
     this.worker.onmessage = this.messageReceived.bind(this);
   }
 
+  get console(): Common.Console.Console {
+    return this.#console;
+  }
+
   createLoader(profileUid: number, snapshotReceivedCallback: (arg0: HeapSnapshotProxy) => void):
       HeapSnapshotLoaderProxy {
     const objectId = this.nextObjectId++;
@@ -159,9 +169,8 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
       return;
     }
     if (data.error) {
-      Common.Console.Console.instance().error(
-          `An error occurred when a call to method '${data.errorMethodName}' was requested`);
-      Common.Console.Console.instance().error(data['errorCallStack']);
+      this.#console.error(`An error occurred when a call to method '${data.errorMethodName}' was requested`);
+      this.#console.error(data['errorCallStack']);
       this.callbacks.delete(data.callId);
       return;
     }
@@ -238,7 +247,7 @@ export class HeapSnapshotLoaderProxy extends HeapSnapshotProxyObject implements
 
   async close(): Promise<void> {
     await this.callMethodPromise('close');
-    const secondWorker = new HeapSnapshotWorkerProxy(() => {}, this.worker.workerUrl);
+    const secondWorker = new HeapSnapshotWorkerProxy(() => {}, this.worker.console, this.worker.workerUrl);
     const channel = new MessageChannel();
     await secondWorker.setupForSecondaryInit(channel.port2);
     const snapshotProxy = await this.callFactoryMethodPromise('buildSnapshot', HeapSnapshotProxy, [channel.port1]);

package/front_end/models/issues_manager/CheckFormsIssuesTrigger.ts

@@ -3,20 +3,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 import type * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 
 /**
  * Responsible for asking autofill for current form issues. This currently happens when devtools is first open.
  */
 // TODO(crbug.com/1399414): Trigger check form issues when an element with an associated issue is editted in the issues panel.
-let checkFormsIssuesTriggerInstance: CheckFormsIssuesTrigger|null = null;
 export class CheckFormsIssuesTrigger {
-  constructor() {
-    SDK.TargetManager.TargetManager.instance().addModelListener(
-        SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this.#pageLoaded, this,
-        {scoped: true});
+  constructor(targetManager: SDK.TargetManager.TargetManager = SDK.TargetManager.TargetManager.instance()) {
+    targetManager.addModelListener(SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load,
+                                   this.#pageLoaded, this, {scoped: true});
 
-    for (const model of SDK.TargetManager.TargetManager.instance().models(SDK.ResourceTreeModel.ResourceTreeModel)) {
+    for (const model of targetManager.models(SDK.ResourceTreeModel.ResourceTreeModel)) {
       if (model.target().outermostTarget() !== model.target()) {
         continue;
       }
@@ -26,10 +25,10 @@ export class CheckFormsIssuesTrigger {
   }
 
   static instance({forceNew}: {forceNew: boolean} = {forceNew: false}): CheckFormsIssuesTrigger {
-    if (!checkFormsIssuesTriggerInstance || forceNew) {
-      checkFormsIssuesTriggerInstance = new CheckFormsIssuesTrigger();
+    if (!Root.DevToolsContext.globalInstance().has(CheckFormsIssuesTrigger) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(CheckFormsIssuesTrigger, new CheckFormsIssuesTrigger());
     }
-    return checkFormsIssuesTriggerInstance;
+    return Root.DevToolsContext.globalInstance().get(CheckFormsIssuesTrigger);
   }
 
   // TODO(crbug.com/1399414): Handle response by dropping current issues in favor of new ones.

package/front_end/models/issues_manager/RelatedIssue.ts

@@ -6,7 +6,7 @@ import * as Common from '../../core/common/common.js';
 import * as SDK from '../../core/sdk/sdk.js';
 
 import type {Issue, IssueCategory} from './Issue.js';
-import {IssuesManager} from './IssuesManager.js';
+import type {IssuesManager} from './IssuesManager.js';
 
 export type IssuesAssociatable = Readonly<SDK.NetworkRequest.NetworkRequest>|SDK.Cookie.Cookie|string;
 
@@ -45,24 +45,26 @@ export function issuesAssociatedWith(issues: Issue[], obj: IssuesAssociatable):
   throw new Error(`issues can not be associated with ${JSON.stringify(obj)}`);
 }
 
-export function hasIssues(obj: IssuesAssociatable): boolean {
-  const issues = Array.from(IssuesManager.instance().issues());
+export function hasIssues(obj: IssuesAssociatable, issuesManager: IssuesManager): boolean {
+  const issues = Array.from(issuesManager.issues());
   return issuesAssociatedWith(issues, obj).length > 0;
 }
 
-export function hasIssueOfCategory(obj: IssuesAssociatable, category: IssueCategory): boolean {
-  const issues = Array.from(IssuesManager.instance().issues());
+export function hasIssueOfCategory(obj: IssuesAssociatable, category: IssueCategory,
+                                   issuesManager: IssuesManager): boolean {
+  const issues = Array.from(issuesManager.issues());
   return issuesAssociatedWith(issues, obj).some(issue => issue.getCategory() === category);
 }
 
-export async function reveal(obj: IssuesAssociatable, category?: IssueCategory): Promise<void|undefined> {
+export async function reveal(obj: IssuesAssociatable, issuesManager: IssuesManager,
+                             category?: IssueCategory): Promise<void|undefined> {
   if (typeof obj === 'string') {
-    const issue = IssuesManager.instance().getIssueById(obj);
+    const issue = issuesManager.getIssueById(obj);
     if (issue) {
       return await Common.Revealer.reveal(issue);
     }
   }
-  const issues = Array.from(IssuesManager.instance().issues());
+  const issues = Array.from(issuesManager.issues());
   const candidates = issuesAssociatedWith(issues, obj).filter(issue => !category || issue.getCategory() === category);
   if (candidates.length > 0) {
     return await Common.Revealer.reveal(candidates[0]);

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -8292,7 +8292,7 @@ export const NativeFunctions = [
   },
   {
     name: "setAttributionReporting",
-    signatures: [["attributionReporting"]]
+    signatures: [["options"]]
   },
   {
     name: "Worker",

package/front_end/models/logs/RequestResolver.ts

@@ -6,7 +6,7 @@ import * as Common from '../../core/common/common.js';
 import type * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 
-import {Events as NetworkLogEvents, NetworkLog} from './NetworkLog.js';
+import {Events as NetworkLogEvents, type NetworkLog} from './NetworkLog.js';
 
 /**
  * A class that facilitates resolving a requestId to a network request. If the requestId does not resolve, a listener
@@ -22,7 +22,7 @@ export class RequestResolver extends
   private networkListener: Common.EventTarget.EventDescriptor|null = null;
   private networkLog: NetworkLog;
 
-  constructor(networkLog: NetworkLog = NetworkLog.instance()) {
+  constructor(networkLog: NetworkLog) {
     super();
     this.networkLog = networkLog;
   }

package/front_end/models/persistence/AutomaticFileSystemWorkspaceBinding.ts

@@ -6,7 +6,6 @@ import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import type * as Platform from '../../core/platform/platform.js';
 import * as Root from '../../core/root/root.js';
-import type * as SDK from '../../core/sdk/sdk.js';
 import type {ContentDataOrError} from '../text_utils/ContentData.js';
 import type {SearchMatch} from '../text_utils/ContentProvider.js';
 import * as Workspace from '../workspace/workspace.js';
@@ -169,10 +168,6 @@ export class FileSystem implements Workspace.Workspace.Project {
   uiSourceCodes(): Iterable<Workspace.UISourceCode.UISourceCode> {
     return [];
   }
-
-  target(): SDK.Target.Target|null {
-    return null;
-  }
 }
 
 /**

package/front_end/models/source_map_scopes/FunctionCodeResolver.ts

@@ -216,17 +216,18 @@ function createFunctionCode(
  */
 export async function getFunctionCodeFromLocation(
     target: SDK.Target.Target, url: Platform.DevToolsPath.UrlString, line: number, column: number,
-    options?: CreateFunctionCodeOptions): Promise<FunctionCode|null> {
+    options?: CreateFunctionCodeOptions,
+    debuggerWorkspaceBinding =
+        Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()): Promise<FunctionCode|null> {
   const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
   if (!debuggerModel) {
     throw new Error('missing debugger model');
   }
 
   let uiSourceCode: Workspace.UISourceCode.UISourceCode|null = null;
-  const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
   const projects = debuggerWorkspaceBinding.workspace.projectsForType(Workspace.Workspace.projectTypes.Network);
   for (const project of projects) {
-    if (project.target() !== target) {
+    if (Bindings.NetworkProject.NetworkProject.getTargetForProject(project) !== target) {
       continue;
     }
     uiSourceCode = project.uiSourceCodeForURL(url);
@@ -245,7 +246,7 @@ export async function getFunctionCodeFromLocation(
     return null;
   }
 
-  return await getFunctionCodeFromRawLocation(rawLocation, options);
+  return await getFunctionCodeFromRawLocation(rawLocation, options, debuggerWorkspaceBinding);
 }
 
 async function format(uiSourceCode: Workspace.UISourceCode.UISourceCode, content: string,
@@ -264,8 +265,9 @@ async function format(uiSourceCode: Workspace.UISourceCode.UISourceCode, content
  * Returns a {@link FunctionCode} for the given raw location.
  */
 export async function getFunctionCodeFromRawLocation(
-    rawLocation: SDK.DebuggerModel.Location, options?: CreateFunctionCodeOptions): Promise<FunctionCode|null> {
-  const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
+    rawLocation: SDK.DebuggerModel.Location, options?: CreateFunctionCodeOptions,
+    debuggerWorkspaceBinding =
+        Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()): Promise<FunctionCode|null> {
   const functionBounds = await debuggerWorkspaceBinding.functionBoundsAtRawLocation(rawLocation);
   if (!functionBounds) {
     return null;

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -2,7 +2,6 @@
 // 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 * as Protocol from '../../generated/protocol.js';
 import * as Bindings from '../bindings/bindings.js';
@@ -190,7 +189,11 @@ const enum Punctuation {
 
 const resolveDebuggerScope = async(scope: SDK.DebuggerModel.ScopeChainEntry):
     Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => {
-      if (!Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get()) {
+      if (!scope.callFrame()
+               .debuggerModel.target()
+               .targetManager()
+               .settings.moduleSetting('js-source-maps-enabled')
+               .get()) {
         return {variableMapping: new Map(), thisMapping: null};
       }
       const script = scope.callFrame().script;
@@ -278,16 +281,17 @@ const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.Form
 
       async function resolveSourceName(
           script: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap, name: string,
-          position: {lineNumber: number, columnNumber: number}): Promise<string|null> {
+          position: {lineNumber: number, columnNumber: number},
+          debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding =
+              Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()): Promise<string|null> {
         const ranges = sourceMap.findEntryRanges(position.lineNumber, position.columnNumber);
         if (!ranges) {
           return null;
         }
         // Extract the underlying text from the compiled code's range and make sure that
         // it starts with the identifier |name|.
-        const uiSourceCode =
-            Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance().uiSourceCodeForSourceMapSourceURL(
-                script.debuggerModel, ranges.sourceURL, script.isContentScript());
+        const uiSourceCode = debuggerWorkspaceBinding.uiSourceCodeForSourceMapSourceURL(
+            script.debuggerModel, ranges.sourceURL, script.isContentScript());
         if (!uiSourceCode) {
           return null;
         }
@@ -363,24 +367,27 @@ const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.Form
     };
 
 export const resolveScopeChain =
-    async function(callFrame: SDK.DebuggerModel.CallFrame): Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
-  const {pluginManager} = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
-  const scopeChain: SDK.DebuggerModel.ScopeChainEntry[]|null|undefined =
-      await pluginManager.resolveScopeChain(callFrame);
-  if (scopeChain) {
-    return scopeChain;
-  }
+    async function(callFrame: SDK.DebuggerModel.CallFrame,
+                   debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding =
+                       Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()):
+        Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
+          const {pluginManager} = debuggerWorkspaceBinding;
+          const scopeChain: SDK.DebuggerModel.ScopeChainEntry[]|null|undefined =
+              await pluginManager.resolveScopeChain(callFrame);
+          if (scopeChain) {
+            return scopeChain;
+          }
 
-  // TODO(crbug.com/465968290): Re-enable creating the scope chain from the source map once:
-  //    1) We have a flag indicating whether the source map contained variable/binding information.
-  //    2) We have a chrome feature flag.
+          // TODO(crbug.com/465968290): Re-enable creating the scope chain from the source map once:
+          //    1) We have a flag indicating whether the source map contained variable/binding information.
+          //    2) We have a chrome feature flag.
 
-  if (callFrame.script.isWasm()) {
-    return callFrame.scopeChain();
-  }
-  const thisObject = await resolveThisObject(callFrame);
-  return callFrame.scopeChain().map(scope => new ScopeWithSourceMappedVariables(scope, thisObject));
-};
+          if (callFrame.script.isWasm()) {
+            return callFrame.scopeChain();
+          }
+          const thisObject = await resolveThisObject(callFrame);
+          return callFrame.scopeChain().map(scope => new ScopeWithSourceMappedVariables(scope, thisObject));
+        };
 
 /**
  * @returns A mapping from original name -> compiled name. If the orignal name is unavailable (e.g. because the compiled name was
@@ -388,7 +395,7 @@ export const resolveScopeChain =
  */
 export const allVariablesInCallFrame =
     async(callFrame: SDK.DebuggerModel.CallFrame): Promise<Map<string, string|null>> => {
-  if (!Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get()) {
+  if (!callFrame.debuggerModel.target().targetManager().settings.moduleSetting('js-source-maps-enabled').get()) {
     return new Map<string, string|null>();
   }
   const cachedMap = cachedMapByCallFrame.get(callFrame);
@@ -424,13 +431,13 @@ export const allVariablesInCallFrame =
 export const allVariablesAtPosition =
     async(location: SDK.DebuggerModel.Location): Promise<Map<string, string|null>> => {
   const reverseMapping = new Map<string, string|null>();
-  if (!Common.Settings.Settings.instance().moduleSetting('js-source-maps-enabled').get()) {
-    return reverseMapping;
-  }
   const script = location.script();
   if (!script) {
     return reverseMapping;
   }
+  if (!script.debuggerModel.target().targetManager().settings.moduleSetting('js-source-maps-enabled').get()) {
+    return reverseMapping;
+  }
 
   const scopeTreeAndText = await computeScopeTree(script);
   if (!scopeTreeAndText) {
@@ -727,8 +734,9 @@ export async function resolveDebuggerFrameFunctionName(frame: SDK.DebuggerModel.
 }
 
 export async function resolveProfileFrameFunctionName(
-    {scriptId, lineNumber, columnNumber}: Partial<Protocol.Runtime.CallFrame>,
-    target: SDK.Target.Target|null): Promise<string|null> {
+    {scriptId, lineNumber, columnNumber}: Partial<Protocol.Runtime.CallFrame>, target: SDK.Target.Target|null,
+    debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding =
+        Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()): Promise<string|null> {
   if (!target || lineNumber === undefined || columnNumber === undefined || scriptId === undefined) {
     return null;
   }
@@ -738,8 +746,6 @@ export async function resolveProfileFrameFunctionName(
   if (!debuggerModel || !script) {
     return null;
   }
-
-  const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
   const location = new SDK.DebuggerModel.Location(debuggerModel, scriptId, lineNumber, columnNumber);
   const functionInfoFromPlugin = await debuggerWorkspaceBinding.pluginManager.getFunctionInfo(script, location);
   if (functionInfoFromPlugin && 'frames' in functionInfoFromPlugin) {

package/front_end/models/stack_trace/StackTrace.ts

@@ -4,6 +4,7 @@
 
 import type * as Common from '../../core/common/common.js';
 import type * as SDK from '../../core/sdk/sdk.js';
+import type * as Protocol from '../../generated/protocol.js';
 import type * as Workspace from '../workspace/workspace.js';
 
 export type StackTrace = BaseStackTrace<Fragment>;
@@ -131,3 +132,19 @@ export class DebuggableFrameFlavor {
     return DebuggableFrameFlavor.#last;
   }
 }
+
+/**
+ * Returns whether the given stack trace originated from a direct console
+ * invocation. A console-originated stack trace has exactly one frame with
+ * no url and no function name.
+ *
+ * TODO(crbug.com/40726969): Accept a translated `StackTrace` instead of a raw `Protocol.Runtime.StackTrace`.
+ */
+export function isConsoleOriginated(stackTrace: Protocol.Runtime.StackTrace): boolean {
+  const callFrames = stackTrace.callFrames;
+  if (callFrames.length !== 1) {
+    return false;
+  }
+  const frame = callFrames[0];
+  return frame.url === '' && frame.functionName === '';
+}

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

@@ -6,7 +6,6 @@ import * as Platform from '../../../core/platform/platform.js';
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
-import {type AuctionWorkletsData, data as auctionWorkletsData} from './AuctionWorkletsHandler.js';
 import {data as layerTreeHandlerData, type LayerTreeData} from './LayerTreeHandler.js';
 import {data as metaHandlerData, type MetaHandlerData} from './MetaHandler.js';
 import {data as rendererHandlerData, type RendererHandlerData} from './RendererHandler.js';
@@ -81,7 +80,6 @@ export async function finalize(): Promise<void> {
   const modelForTrace = new TimelineFrameModel(
       relevantFrameEvents,
       rendererHandlerData(),
-      auctionWorkletsData(),
       metaHandlerData(),
       layerTreeHandlerData(),
   );
@@ -101,7 +99,7 @@ export function data(): FramesData {
 }
 
 export function deps(): HandlerName[] {
-  return ['Meta', 'Renderer', 'AuctionWorklets', 'LayerTree'];
+  return ['Meta', 'Renderer', 'LayerTree'];
 }
 
 export class TimelineFrameModel {
@@ -122,13 +120,12 @@ export class TimelineFrameModel {
   #activeThreadId: Types.Events.ThreadID|null = null;
   #layerTreeData: LayerTreeData;
 
-  constructor(
-      allEvents: readonly Types.Events.Event[], rendererData: RendererHandlerData,
-      auctionWorkletsData: AuctionWorkletsData, metaData: MetaHandlerData, layerTreeData: LayerTreeData) {
+  constructor(allEvents: readonly Types.Events.Event[], rendererData: RendererHandlerData, metaData: MetaHandlerData,
+              layerTreeData: LayerTreeData) {
     // We only care about getting threads from the Renderer, not Samples,
     // because Frames don't exist in a CPU Profile (which won't have Renderer
     // threads.)
-    const mainThreads = Threads.threadsInRenderer(rendererData, auctionWorkletsData).filter(thread => {
+    const mainThreads = Threads.threadsInRenderer(rendererData).filter(thread => {
       return thread.type === Threads.ThreadType.MAIN_THREAD && thread.processIsOnMainFrame;
     });
     const threadData = mainThreads.map(thread => {

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

@@ -5,7 +5,6 @@
 export * as AnimationFrames from './AnimationFramesHandler.js';
 export * as Animations from './AnimationHandler.js';
 export * as AsyncJSCalls from './AsyncJSCallsHandler.js';
-export * as AuctionWorklets from './AuctionWorkletsHandler.js';
 export * as DOMStats from './DOMStatsHandler.js';
 export * as ExtensionTraceData from './ExtensionTraceDataHandler.js';
 export * as Flows from './FlowsHandler.js';

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

@@ -6,7 +6,6 @@ import * as Platform from '../../../core/platform/platform.js';
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
-import {data as auctionWorkletsData} from './AuctionWorkletsHandler.js';
 import * as HandlerHelpers from './helpers.js';
 import {data as metaHandlerData, type FrameProcessData} from './MetaHandler.js';
 import {data as networkRequestHandlerData} from './NetworkRequestsHandler.js';
@@ -248,7 +247,6 @@ export function assignThreadName(
  *  - Deletes processes with an unknown origin.
  */
 export function sanitizeProcesses(processes: Map<Types.Events.ProcessID, RendererProcess>): void {
-  const auctionWorklets = auctionWorkletsData().worklets;
   const metaData = metaHandlerData();
   if (metaData.traceIsGeneric) {
     return;
@@ -258,19 +256,8 @@ export function sanitizeProcesses(processes: Map<Types.Events.ProcessID, Rendere
     // parsed for some reason, or if it's an "about:" origin, delete it.
     // This is done because we don't really care about processes for which we
     // can't provide actionable insights to the user (e.g. about:blank pages).
-    //
-    // There is one exception; AuctionWorklet processes get parsed in a
-    // separate handler, so at this point we check to see if the process has
-    // been found by the AuctionWorkletsHandler, and if so we update the URL.
-    // This ensures that we keep this process around and do not drop it due to
-    // the lack of a URL.
     if (process.url === null) {
-      const maybeWorklet = auctionWorklets.get(pid);
-      if (maybeWorklet) {
-        process.url = maybeWorklet.host;
-      } else {
-        processes.delete(pid);
-      }
+      processes.delete(pid);
       continue;
     }
   }
@@ -392,7 +379,7 @@ export function makeCompleteEvent(event: Types.Events.Begin|Types.Events.End): T
 }
 
 export function deps(): HandlerName[] {
-  return ['Meta', 'Samples', 'AuctionWorklets', 'NetworkRequests'];
+  return ['Meta', 'Samples', 'NetworkRequests'];
 }
 
 export interface RendererHandlerData {

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

@@ -5,7 +5,6 @@
 import type * as Helpers from '../helpers/helpers.js';
 import type * as Types from '../types/types.js';
 
-import type {AuctionWorkletsData} from './AuctionWorkletsHandler.js';
 import type * as Renderer from './RendererHandler.js';
 import type {HandlerData} from './types.js';
 
@@ -24,15 +23,12 @@ export const enum ThreadType {
   MAIN_THREAD = 'MAIN_THREAD',
   WORKER = 'WORKER',
   RASTERIZER = 'RASTERIZER',
-  AUCTION_WORKLET = 'AUCTION_WORKLET',
   OTHER = 'OTHER',
   CPU_PROFILE = 'CPU_PROFILE',
   THREAD_POOL = 'THREAD_POOL',
 }
 
-function getThreadTypeForRendererThread(
-    pid: Types.Events.ProcessID, thread: Renderer.RendererThread,
-    auctionWorkletsData: AuctionWorkletsData): ThreadType {
+function getThreadTypeForRendererThread(pid: Types.Events.ProcessID, thread: Renderer.RendererThread): ThreadType {
   let threadType = ThreadType.OTHER;
   if (thread.name === 'CrRendererMain') {
     threadType = ThreadType.MAIN_THREAD;
@@ -40,8 +36,6 @@ function getThreadTypeForRendererThread(
     threadType = ThreadType.WORKER;
   } else if (thread.name?.startsWith('CompositorTileWorker')) {
     threadType = ThreadType.RASTERIZER;
-  } else if (auctionWorkletsData.worklets.has(pid)) {
-    threadType = ThreadType.AUCTION_WORKLET;
   } else if (thread.name?.startsWith('ThreadPool')) {
     // TODO(paulirish): perhaps exclude ThreadPoolServiceThread entirely
     threadType = ThreadType.THREAD_POOL;
@@ -49,8 +43,7 @@ function getThreadTypeForRendererThread(
   return threadType;
 }
 
-export function threadsInRenderer(
-    rendererData: Renderer.RendererHandlerData, auctionWorkletsData: AuctionWorkletsData): readonly ThreadData[] {
+export function threadsInRenderer(rendererData: Renderer.RendererHandlerData): readonly ThreadData[] {
   const foundThreads: ThreadData[] = [];
   // If we have Renderer threads, we prefer to use those. In the event that a
   // trace is a CPU Profile trace, we will never have Renderer threads, so we
@@ -65,7 +58,7 @@ export function threadsInRenderer(
           // filtering we need.
           continue;
         }
-        const threadType = getThreadTypeForRendererThread(pid, thread, auctionWorkletsData);
+        const threadType = getThreadTypeForRendererThread(pid, thread);
         foundThreads.push({
           name: thread.name,
           pid,
@@ -99,7 +92,7 @@ export function threadsInTrace(handlerData: HandlerData): readonly ThreadData[]
   }
 
   // If we have Renderer threads, we prefer to use those.
-  const threadsFromRenderer = threadsInRenderer(handlerData.Renderer, handlerData.AuctionWorklets);
+  const threadsFromRenderer = threadsInRenderer(handlerData.Renderer);
   if (threadsFromRenderer.length) {
     threadsInHandlerDataCache.set(handlerData, threadsFromRenderer);
     return threadsFromRenderer;

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

@@ -117,7 +117,7 @@ export function generateInsight(data: Handlers.Types.HandlerData, context: Insig
   const largeLayoutUpdates: Types.Events.Layout[] = [];
   const largeStyleRecalcs: Types.Events.RecalcStyle[] = [];
 
-  const threads = Handlers.Threads.threadsInRenderer(data.Renderer, data.AuctionWorklets);
+  const threads = Handlers.Threads.threadsInRenderer(data.Renderer);
   for (const thread of threads) {
     if (thread.type !== Handlers.Threads.ThreadType.MAIN_THREAD) {
       continue;

package/front_end/models/workspace/WorkspaceImpl.ts

@@ -5,7 +5,6 @@
 import * as Common from '../../core/common/common.js';
 import type * as Platform from '../../core/platform/platform.js';
 import * as Root from '../../core/root/root.js';
-import type * as SDK from '../../core/sdk/sdk.js';
 import type * as TextUtils from '../text_utils/text_utils.js';
 
 import type {SearchConfig} from './SearchConfig.js';
@@ -55,7 +54,6 @@ export interface Project {
    * @returns an iterator for the sources provided by this project.
    */
   uiSourceCodes(): Iterable<UISourceCode>;
-  target(): SDK.Target.Target|null;
 }
 
 /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
@@ -76,15 +74,12 @@ export abstract class ProjectStore implements Project {
   readonly #type: projectTypes;
   readonly #displayName: string;
   readonly #uiSourceCodes = new Map<Platform.DevToolsPath.UrlString, UISourceCode>();
-  readonly #target: SDK.Target.Target|null = null;
 
-  constructor(workspace: WorkspaceImpl, id: string, type: projectTypes, displayName: string,
-              target: SDK.Target.Target|null = null) {
+  constructor(workspace: WorkspaceImpl, id: string, type: projectTypes, displayName: string) {
     this.#workspace = workspace;
     this.#id = id;
     this.#type = type;
     this.#displayName = displayName;
-    this.#target = target;
   }
 
   id(): string {
@@ -140,10 +135,6 @@ export abstract class ProjectStore implements Project {
     return this.#uiSourceCodes.values();
   }
 
-  target(): SDK.Target.Target|null {
-    return this.#target;
-  }
-
   renameUISourceCode(uiSourceCode: UISourceCode, newName: string): void {
     const oldPath = uiSourceCode.url();
     const newPath = uiSourceCode.parentURL() ?