chrome-devtools-frontend 1.0.1660788 → 1.0.1661063

package/front_end/models/bindings/ContentProviderBasedProject.ts

@@ -5,6 +5,7 @@
 import type * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
+import type * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../text_utils/text_utils.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -26,10 +27,9 @@ interface UISourceCodeData {
 export class ContentProviderBasedProject extends Workspace.Workspace.ProjectStore {
   readonly #isServiceProject: boolean;
   readonly #uiSourceCodeToData = new WeakMap<Workspace.UISourceCode.UISourceCode, UISourceCodeData>();
-  constructor(
-      workspace: Workspace.Workspace.WorkspaceImpl, id: string, type: Workspace.Workspace.projectTypes,
-      displayName: string, isServiceProject: boolean) {
-    super(workspace, id, type, displayName);
+  constructor(workspace: Workspace.Workspace.WorkspaceImpl, id: string, type: Workspace.Workspace.projectTypes,
+              displayName: string, isServiceProject: boolean, target: SDK.Target.Target|null = null) {
+    super(workspace, id, type, displayName, target);
     this.#isServiceProject = isServiceProject;
     workspace.addProject(this);
   }

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -1100,10 +1100,9 @@ class ModelData {
   project: 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.project = new ContentProviderBasedProject(workspace, 'language_plugins::' + debuggerModel.target().id(),
+                                                   Workspace.Workspace.projectTypes.Network, '',
+                                                   false /* isServiceProject */, debuggerModel.target());
 
     this.uiSourceCodeToScripts = new Map();
   }

package/front_end/models/bindings/DefaultScriptMapping.ts

@@ -23,9 +23,9 @@ export class DefaultScriptMapping implements DebuggerSourceMapping {
       debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
     defaultScriptMappings.add(this);
     this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
-    this.#project = new ContentProviderBasedProject(
-        workspace, 'debugger:' + debuggerModel.target().id(), Workspace.Workspace.projectTypes.Debugger, '',
-        true /* isServiceProject */);
+    this.#project = new ContentProviderBasedProject(workspace, 'debugger:' + debuggerModel.target().id(),
+                                                    Workspace.Workspace.projectTypes.Debugger, '',
+                                                    true /* isServiceProject */, debuggerModel.target());
     this.#eventListeners = [
       debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this),
       debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this),

package/front_end/models/bindings/NetworkProject.ts

@@ -12,7 +12,6 @@ const uiSourceCodeToAttributionMap = new WeakMap<Workspace.UISourceCode.UISource
                                                    frame: SDK.ResourceTreeModel.ResourceTreeFrame,
                                                    count: number,
                                                  }>>();
-const projectToTargetMap = new WeakMap<Workspace.Workspace.Project, SDK.Target.Target>();
 
 export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
 
@@ -132,15 +131,7 @@ export class NetworkProject {
   }
 
   static targetForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Target.Target|null {
-    return projectToTargetMap.get(uiSourceCode.project()) || null;
-  }
-
-  static setTargetForProject(project: Workspace.Workspace.Project, target: SDK.Target.Target): void {
-    projectToTargetMap.set(project, target);
-  }
-
-  static getTargetForProject(project: Workspace.Workspace.Project): SDK.Target.Target|null {
-    return projectToTargetMap.get(project) || null;
+    return uiSourceCode.project().target();
   }
 
   static framesForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode):

package/front_end/models/bindings/ResourceMapping.ts

@@ -361,10 +361,9 @@ class ModelInfo {
   constructor(resourceMapping: ResourceMapping, resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel) {
     const target = resourceTreeModel.target();
     this.resourceMapping = resourceMapping;
-    this.project = new ContentProviderBasedProject(
-        resourceMapping.workspace, 'resources:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
-        false /* isServiceProject */);
-    NetworkProject.setTargetForProject(this.project, target);
+    this.project = new ContentProviderBasedProject(resourceMapping.workspace, 'resources:' + target.id(),
+                                                   Workspace.Workspace.projectTypes.Network, '',
+                                                   false /* isServiceProject */, target);
 
     const cssModel = target.model(SDK.CSSModel.CSSModel);
     console.assert(Boolean(cssModel));

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -73,9 +73,8 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     if (!project) {
       const projectType = script.isContentScript() ? Workspace.Workspace.projectTypes.ContentScripts :
                                                      Workspace.Workspace.projectTypes.Network;
-      project = new ContentProviderBasedProject(
-          this.#workspace, projectId, projectType, '' /* displayName */, false /* isServiceProject */);
-      NetworkProject.setTargetForProject(project, this.debuggerModel.target());
+      project = new ContentProviderBasedProject(this.#workspace, projectId, projectType, '' /* displayName */,
+                                                false /* isServiceProject */, this.debuggerModel.target());
       this.#projects.set(projectId, project);
     }
     return project;

package/front_end/models/bindings/SASSSourceMapping.ts

@@ -26,10 +26,9 @@ export class SASSSourceMapping implements SourceMapping {
       workspace: Workspace.Workspace.WorkspaceImpl, cssWorkspaceBinding: CSSWorkspaceBinding) {
     this.#sourceMapManager = sourceMapManager;
     this.#cssWorkspaceBinding = cssWorkspaceBinding;
-    this.#project = new ContentProviderBasedProject(
-        workspace, 'cssSourceMaps:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
-        false /* isServiceProject */);
-    NetworkProject.setTargetForProject(this.#project, target);
+    this.#project = new ContentProviderBasedProject(workspace, 'cssSourceMaps:' + target.id(),
+                                                    Workspace.Workspace.projectTypes.Network, '',
+                                                    false /* isServiceProject */, target);
 
     this.#bindings = new Map();
 

package/front_end/models/bindings/StylesSourceMapping.ts

@@ -24,9 +24,9 @@ export class StylesSourceMapping implements SourceMapping {
   constructor(cssModel: SDK.CSSModel.CSSModel, workspace: Workspace.Workspace.WorkspaceImpl) {
     this.#cssModel = cssModel;
     const target = this.#cssModel.target();
-    this.#project = new ContentProviderBasedProject(
-        workspace, 'css:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
-    NetworkProject.setTargetForProject(this.#project, target);
+    this.#project =
+        new ContentProviderBasedProject(workspace, 'css:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
+                                        false /* isServiceProject */, target);
 
     this.#eventListeners = [
       this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetAdded, this.styleSheetAdded, this),

package/front_end/models/bindings/TempFile.ts

@@ -2,12 +2,17 @@
 // 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 type * as Common from '../../core/common/common.js';
 
 import {ChunkedFileReader, type ChunkedReader} from './FileUtils.js';
 
 export class TempFile {
   #lastBlob: Blob|null = null;
+  readonly #console: Common.Console.Console;
+
+  constructor(console: Common.Console.Console) {
+    this.#console = console;
+  }
 
   write(pieces: Array<string|Blob>): void {
     if (this.#lastBlob) {
@@ -26,7 +31,7 @@ export class TempFile {
 
   async readRange(startOffset?: number, endOffset?: number): Promise<string|null> {
     if (!this.#lastBlob) {
-      Common.Console.Console.instance().error('Attempt to read a temp file that was never written');
+      this.#console.error('Attempt to read a temp file that was never written');
       return '';
     }
     const blob = typeof startOffset === 'number' || typeof endOffset === 'number' ?
@@ -41,7 +46,7 @@ export class TempFile {
         reader.readAsText(blob);
       });
     } catch (error) {
-      Common.Console.Console.instance().error('Failed to read from temp file: ' + error.message);
+      this.#console.error('Failed to read from temp file: ' + error.message);
     }
 
     return reader.result as string | null;

package/front_end/models/extensions/ExtensionAPI.ts

@@ -459,9 +459,9 @@ namespace APIImpl {
   }
 
   export interface ExtensionSidebarPane extends ExtensionView, PublicAPI.Chrome.DevTools.ExtensionSidebarPane {
-    setExpression(
-        expression: string, rootTitle?: string, evaluteOptions?: PrivateAPI.EvaluateOptions,
-        callback?: () => unknown): void;
+    setExpression(expression: string, rootTitle?: string, evaluateOptions?: PrivateAPI.EvaluateOptions): Promise<void>;
+    setExpression(expression: string, rootTitle?: string, evaluateOptions?: PrivateAPI.EvaluateOptions,
+                  callback?: () => unknown): void;
   }
 
   export interface PanelWithSidebar extends ExtensionView, PublicAPI.Chrome.DevTools.PanelWithSidebar {
@@ -685,14 +685,29 @@ self.injectedExtensionAPI = function(
 
   (Panels.prototype as
    Pick<APIImpl.Panels, 'create'|'setOpenResourceHandler'|'openResource'|'SearchAction'|'setThemeChangeHandler'>) = {
-    create: function(
-        title: string, _icon: string, page: string,
-        callback: (panel: PublicAPI.Chrome.DevTools.ExtensionPanel) => unknown): void {
-      const id = 'extension-panel-' + extensionServer.nextObjectId();
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.CreatePanel, id, title, page},
-          callback && (() => callback.call(this, new (Constructor(ExtensionPanel))(id))));
-    },
+    create: function(this: APIImpl.Panels, title: string, _iconPath: string, pagePath: string,
+                     _callback?: (panel: PublicAPI.Chrome.DevTools.ExtensionPanel) => unknown):
+                Promise<PublicAPI.Chrome.DevTools.ExtensionPanel>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} =
+              callbackOrPromise<PublicAPI.Chrome.DevTools.ExtensionPanel>(arguments);
+
+          const id = 'extension-panel-' + extensionServer.nextObjectId();
+
+          const callbackWrapper = (response: unknown): void => {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+            const panel = new (Constructor(ExtensionPanel))(id);
+            resolve?.(panel);
+            callbackArg?.call(this, panel);
+          };
+
+          extensionServer.sendRequest({command: PrivateAPI.Commands.CreatePanel, id, title, page: pagePath},
+                                      callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.Panels['create'],
 
     setOpenResourceHandler: function(
         callback: (resource: PublicAPI.Chrome.DevTools.Resource, lineNumber: number, columnNumber: number) => unknown,
@@ -746,15 +761,29 @@ self.injectedExtensionAPI = function(
       }
     },
 
-    openResource: function(
-        url: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber?: number,
-        _callback?: (response: unknown) => unknown): void {
-      const callbackArg = extractCallbackArgument(arguments);
-      // Handle older API:
-      const columnNumberArg = typeof columnNumber === 'number' ? columnNumber : 0;
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.OpenResource, url, lineNumber, columnNumber: columnNumberArg}, callbackArg);
-    },
+    openResource: function(this: APIImpl.Panels, url: Platform.DevToolsPath.UrlString, lineNumber: number,
+                           columnNumber?: number|(() => unknown), _callback?: () => unknown): Promise<void>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<unknown>(arguments);
+          // Handle older API:
+          const columnNumberArg = typeof columnNumber === 'number' ? columnNumber : 0;
+
+          const callbackWrapper = (response: unknown): void => {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+            // `openResource` isn't supposed to send the response from the backend, but some JavaScript callers
+            //  might be relying on it so we send it for now.
+            resolve?.(response);
+            callbackArg?.call(this, response);
+          };
+
+          extensionServer.sendRequest(
+              {command: PrivateAPI.Commands.OpenResource, url, lineNumber, columnNumber: columnNumberArg},
+              callbackWrapper);
+
+          return promise as Promise<void>| undefined;
+        } as PublicAPI.Chrome.DevTools.Panels['openResource'],
 
     get SearchAction(): Record<string, string> {
       return {
@@ -795,17 +824,28 @@ self.injectedExtensionAPI = function(
 
   (PanelWithSidebarImpl.prototype as Pick<APIImpl.PanelWithSidebar, 'createSidebarPane'>&
    {__proto__: APIImpl.ExtensionView}) = {
-    createSidebarPane: function(
-        this: APIImpl.PanelWithSidebar, title: string,
-        callback?: (pane: PublicAPI.Chrome.DevTools.ExtensionSidebarPane) => unknown): void {
-      const id = 'extension-sidebar-' + extensionServer.nextObjectId();
-      function callbackWrapper(): void {
-        callback?.(new (Constructor(ExtensionSidebarPane))(id));
-      }
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.CreateSidebarPane, panel: this._hostPanelName, id, title},
-          callback && callbackWrapper);
-    },
+    createSidebarPane: function(this: APIImpl.PanelWithSidebar, title: string,
+                                _callback?: (pane: PublicAPI.Chrome.DevTools.ExtensionSidebarPane) => unknown):
+                           Promise<PublicAPI.Chrome.DevTools.ExtensionSidebarPane>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} =
+              callbackOrPromise<PublicAPI.Chrome.DevTools.ExtensionSidebarPane>(arguments);
+          const id = 'extension-sidebar-' + extensionServer.nextObjectId();
+
+          const callbackWrapper = (response: unknown): void => {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+            const pane = new (Constructor(ExtensionSidebarPane))(id);
+            resolve?.(pane);
+            callbackArg?.call(this, pane);
+          };
+
+          extensionServer.sendRequest(
+              {command: PrivateAPI.Commands.CreateSidebarPane, panel: this._hostPanelName, id, title}, callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.PanelWithSidebar['createSidebarPane'],
 
     __proto__: ExtensionViewImpl.prototype,
   };
@@ -1125,8 +1165,9 @@ self.injectedExtensionAPI = function(
    *    otherwise.
    */
   function checkErrorAndReject(response: unknown, reject?: (error: Error) => void): boolean {
-    const res = response as {isError?: boolean, description?: string, details?: unknown[]};
-    if (res.isError && reject) {
+    const res = response as {isError?: boolean, description?: string, details?: unknown[]} | undefined;
+    // Sometimes the success response from the backend is `undefined`.
+    if (res?.isError && reject) {
       reject(new Error('DevTools API encountered an error'));
       return true;
     }
@@ -1220,11 +1261,20 @@ self.injectedExtensionAPI = function(
       extensionServer.sendRequest({command: PrivateAPI.Commands.SetSidebarHeight, id: this._id as string, height});
     },
 
-    setExpression: function(
-        this: APIImpl.ExtensionSidebarPane, expression: string, rootTitle: string,
-        evaluateOptions?: PrivateAPI.EvaluateOptions, _callback?: () => unknown): void {
-      extensionServer.sendRequest(
-          {
+    setExpression: function(this: APIImpl.ExtensionSidebarPane, expression: string, rootTitle?: string,
+                            evaluateOptions?: PrivateAPI.EvaluateOptions, _callback?: () => unknown): Promise<void>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<void>(arguments);
+
+          const callbackWrapper = (response: unknown): void => {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+            resolve?.();
+            callbackArg?.call(this);
+          };
+
+          extensionServer.sendRequest({
             command: PrivateAPI.Commands.SetSidebarContent,
             id: this._id as string,
             expression,
@@ -1232,20 +1282,34 @@ self.injectedExtensionAPI = function(
             evaluateOnPage: true,
             evaluateOptions: (typeof evaluateOptions === 'object' ? evaluateOptions : {}),
           },
-          extractCallbackArgument(arguments));
-    },
+                                      callbackWrapper);
 
-    setObject: function(
-        this: APIImpl.ExtensionSidebarPane, jsonObject: string, rootTitle?: string, callback?: () => unknown): void {
-      extensionServer.sendRequest(
-          {
+          return promise;
+        } as PublicAPI.Chrome.DevTools.ExtensionSidebarPane['setExpression'],
+
+    setObject: function(this: APIImpl.ExtensionSidebarPane, jsonObject: string, rootTitle?: string,
+                        _callback?: () => unknown): Promise<void>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<void>(arguments);
+
+          const callbackWrapper = (response: unknown): void => {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+            resolve?.();
+            callbackArg?.call(this);
+          };
+
+          extensionServer.sendRequest({
             command: PrivateAPI.Commands.SetSidebarContent,
             id: this._id as string,
             expression: jsonObject,
             rootTitle,
           },
-          callback);
-    },
+                                      callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.ExtensionSidebarPane['setObject'],
 
     setPage: function(this: APIImpl.ExtensionSidebarPane, page: string): void {
       extensionServer.sendRequest({command: PrivateAPI.Commands.SetSidebarPage, id: this._id as string, page});

package/front_end/models/formatter/ScriptFormatter.ts

@@ -2,7 +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 type * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
 import type * as FormatterActions from '../../entrypoints/formatter_worker/FormatterActions.js';
 
@@ -30,28 +30,25 @@ export interface FormattedContent {
   formattedMapping: FormatterSourceMapping;
 }
 
-export async function format(
-    contentType: Common.ResourceType.ResourceType, mimeType: string, content: string,
-    indent: string =
-        Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get()): Promise<FormattedContent> {
+export async function format(settings: Common.Settings.Settings, contentType: Common.ResourceType.ResourceType,
+                             mimeType: string, content: string, indent?: string): Promise<FormattedContent> {
   if (contentType.isDocumentOrScriptOrStyleSheet()) {
-    return await formatScriptContent(mimeType, content, indent);
+    return await formatScriptContent(settings, mimeType, content, indent);
   }
 
   return {formattedContent: content, formattedMapping: new IdentityFormatterSourceMapping()};
 }
 
-export async function formatScriptContent(
-    mimeType: string, content: string,
-    indent: string =
-        Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get()): Promise<FormattedContent> {
+export async function formatScriptContent(settings: Common.Settings.Settings, mimeType: string, content: string,
+                                          indent?: string): Promise<FormattedContent> {
+  const indentString = indent ?? settings.moduleSetting('text-editor-indent').get();
   const originalContent = content.replace(/\r\n?|[\n\u2028\u2029]/g, '\n').replace(/^\uFEFF/, '');
 
   const pool = formatterWorkerPool();
 
   let formatResult: FormatterActions.FormatResult = {content: originalContent, mapping: {original: [], formatted: []}};
   try {
-    formatResult = await pool.format(mimeType, originalContent, indent);
+    formatResult = await pool.format(mimeType, originalContent, indentString);
   } catch {
   }
   const originalContentLineEndings = Platform.StringUtilities.findLineEndingIndexes(originalContent);

package/front_end/models/issues_manager/CookieIssue.ts

@@ -53,6 +53,15 @@ export const enum CookieStatus {
 }
 
 export class CookieIssue extends Issue<Protocol.Audits.CookieIssueDetails> {
+  readonly #frameManager: SDK.FrameManager.FrameManager;
+
+  constructor(code: string, issueDetails: Protocol.Audits.CookieIssueDetails,
+              issuesModel: SDK.IssuesModel.IssuesModel|null, issueId: Protocol.Audits.IssueId|undefined,
+              frameManager: SDK.FrameManager.FrameManager) {
+    super(code, issueDetails, issuesModel, issueId);
+    this.#frameManager = frameManager;
+  }
+
   cookieId(): string {
     const details = this.details();
     if (details.cookie) {
@@ -72,9 +81,10 @@ export class CookieIssue extends Issue<Protocol.Audits.CookieIssueDetails> {
   /**
    * Returns an array of issues from a given CookieIssueDetails.
    */
-  static createIssuesFromCookieIssueDetails(
-      cookieIssueDetails: Protocol.Audits.CookieIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel|null,
-      issueId: Protocol.Audits.IssueId|undefined): CookieIssue[] {
+  static createIssuesFromCookieIssueDetails(cookieIssueDetails: Protocol.Audits.CookieIssueDetails,
+                                            issuesModel: SDK.IssuesModel.IssuesModel|null,
+                                            issueId: Protocol.Audits.IssueId|undefined,
+                                            frameManager: SDK.FrameManager.FrameManager): CookieIssue[] {
     const issues: CookieIssue[] = [];
 
     // Exclusion reasons have priority. It means a cookie was blocked. Create an issue
@@ -86,7 +96,7 @@ export class CookieIssue extends Issue<Protocol.Audits.CookieIssueDetails> {
             exclusionReason, cookieIssueDetails.cookieWarningReasons, cookieIssueDetails.operation,
             cookieIssueDetails.cookieUrl as Platform.DevToolsPath.UrlString | undefined);
         if (code) {
-          issues.push(new CookieIssue(code, cookieIssueDetails, issuesModel, issueId));
+          issues.push(new CookieIssue(code, cookieIssueDetails, issuesModel, issueId, frameManager));
         }
       }
       return issues;
@@ -99,7 +109,7 @@ export class CookieIssue extends Issue<Protocol.Audits.CookieIssueDetails> {
             warningReason, [], cookieIssueDetails.operation,
             cookieIssueDetails.cookieUrl as Platform.DevToolsPath.UrlString | undefined);
         if (code) {
-          issues.push(new CookieIssue(code, cookieIssueDetails, issuesModel, issueId));
+          issues.push(new CookieIssue(code, cookieIssueDetails, issuesModel, issueId, frameManager));
         }
       }
     }
@@ -223,7 +233,7 @@ export class CookieIssue extends Issue<Protocol.Audits.CookieIssueDetails> {
   }
 
   override isCausedByThirdParty(): boolean {
-    const outermostFrame = SDK.FrameManager.FrameManager.instance().getOutermostFrame();
+    const outermostFrame = this.#frameManager.getOutermostFrame();
     return isCausedByThirdParty(outermostFrame, this.details().cookieUrl, this.details().siteForCookies);
   }
 
@@ -257,15 +267,17 @@ export class CookieIssue extends Issue<Protocol.Audits.CookieIssueDetails> {
     return;
   }
 
-  static fromInspectorIssue(
-      issuesModel: SDK.IssuesModel.IssuesModel|null, inspectorIssue: Protocol.Audits.InspectorIssue): CookieIssue[] {
+  static fromInspectorIssue(issuesModel: SDK.IssuesModel.IssuesModel|null,
+                            inspectorIssue: Protocol.Audits.InspectorIssue,
+                            frameManager: SDK.FrameManager.FrameManager): CookieIssue[] {
     const cookieIssueDetails = inspectorIssue.details.cookieIssueDetails;
     if (!cookieIssueDetails) {
       console.warn('Cookie issue without details received.');
       return [];
     }
 
-    return CookieIssue.createIssuesFromCookieIssueDetails(cookieIssueDetails, issuesModel, inspectorIssue.issueId);
+    return CookieIssue.createIssuesFromCookieIssueDetails(cookieIssueDetails, issuesModel, inspectorIssue.issueId,
+                                                          frameManager);
   }
 
   static getSubCategory(code: string): CookieIssueSubCategory {

package/front_end/models/issues_manager/Issue.ts

@@ -2,7 +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 type * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import type * as Platform from '../../core/platform/platform.js';
@@ -49,7 +49,6 @@ export const enum IssueCategory {
   CONTENT_SECURITY_POLICY = 'ContentSecurityPolicy',
   LOW_TEXT_CONTRAST = 'LowTextContrast',
   CORS = 'Cors',
-  ATTRIBUTION_REPORTING = 'AttributionReporting',
   QUIRKS_MODE = 'QuirksMode',
   PERMISSION_ELEMENT = 'PermissionElement',
   SELECTIVE_PERMISSIONS_INTERVENTION = 'SelectivePermissionsIntervention',
@@ -112,8 +111,8 @@ export function unionIssueKind(a: IssueKind, b: IssueKind): IssueKind {
   return IssueKind.IMPROVEMENT;
 }
 
-export function getShowThirdPartyIssuesSetting(): Common.Settings.Setting<boolean> {
-  return Common.Settings.Settings.instance().createSetting('show-third-party-issues', true);
+export function getShowThirdPartyIssuesSetting(settings: Common.Settings.Settings): Common.Settings.Setting<boolean> {
+  return settings.createSetting('show-third-party-issues', true);
 }
 
 export interface AffectedElement {

package/front_end/models/issues_manager/IssueAggregator.ts

@@ -5,7 +5,6 @@
 import * as Common from '../../core/common/common.js';
 import type * as Protocol from '../../generated/protocol.js';
 
-import {AttributionReportingIssue} from './AttributionReportingIssue.js';
 import {ContentSecurityPolicyIssue} from './ContentSecurityPolicyIssue.js';
 import {CookieDeprecationMetadataIssue} from './CookieDeprecationMetadataIssue.js';
 import {CookieIssue} from './CookieIssue.js';
@@ -71,7 +70,6 @@ export class AggregatedIssue extends Issue {
   #selectivePermissionsInterventionIssues = new Set<SelectivePermissionsInterventionIssue>();
   #sharedArrayBufferIssues = new Set<SharedArrayBufferIssue>();
   #quirksModeIssues = new Set<QuirksModeIssue>();
-  #attributionReportingIssues = new Set<AttributionReportingIssue>();
   #genericIssues = new Set<GenericIssue>();
   #elementAccessibilityIssues = new Set<ElementAccessibilityIssue>();
   #representative?: Issue;
@@ -158,10 +156,6 @@ export class AggregatedIssue extends Issue {
     return this.#quirksModeIssues;
   }
 
-  getAttributionReportingIssues(): ReadonlySet<AttributionReportingIssue> {
-    return this.#attributionReportingIssues;
-  }
-
   getGenericIssues(): ReadonlySet<GenericIssue> {
     return this.#genericIssues;
   }
@@ -273,9 +267,6 @@ export class AggregatedIssue extends Issue {
     if (issue instanceof QuirksModeIssue) {
       this.#quirksModeIssues.add(issue);
     }
-    if (issue instanceof AttributionReportingIssue) {
-      this.#attributionReportingIssues.add(issue);
-    }
     if (issue instanceof GenericIssue) {
       this.#genericIssues.add(issue);
     }

package/front_end/models/issues_manager/IssueResolver.ts

@@ -6,7 +6,7 @@ import * as Common from '../../core/common/common.js';
 import type * as Protocol from '../../generated/protocol.js';
 
 import type {Issue} from './Issue.js';
-import {Events as IssueManagerEvents, type IssueAddedEvent, IssuesManager} from './IssuesManager.js';
+import {Events as IssueManagerEvents, type IssueAddedEvent, type IssuesManager} from './IssuesManager.js';
 
 /**
  * A class that facilitates resolving an issueId to an issue. See `ResolverBase` for more info.
@@ -15,7 +15,7 @@ export class IssueResolver extends Common.ResolverBase.ResolverBase<Protocol.Aud
   #issuesListener: Common.EventTarget.EventDescriptor|null = null;
   #issuesManager: IssuesManager;
 
-  constructor(issuesManager: IssuesManager = IssuesManager.instance()) {
+  constructor(issuesManager: IssuesManager) {
     super();
     this.#issuesManager = issuesManager;
   }