chrome-devtools-frontend 1.0.950850 → 1.0.952284

package/front_end/models/issues_manager/ContrastCheckTrigger.ts

@@ -9,9 +9,9 @@ import * as SDK from '../../core/sdk/sdk.js';
 let contrastCheckTriggerInstance: ContrastCheckTrigger|null = null;
 
 export class ContrastCheckTrigger {
-  private pageLoadListeners: WeakMap<SDK.ResourceTreeModel.ResourceTreeModel, Common.EventTarget.EventDescriptor> =
+  #pageLoadListeners: WeakMap<SDK.ResourceTreeModel.ResourceTreeModel, Common.EventTarget.EventDescriptor> =
       new WeakMap();
-  private frameAddedListeners: WeakMap<SDK.ResourceTreeModel.ResourceTreeModel, Common.EventTarget.EventDescriptor> =
+  #frameAddedListeners: WeakMap<SDK.ResourceTreeModel.ResourceTreeModel, Common.EventTarget.EventDescriptor> =
       new WeakMap();
 
   constructor() {
@@ -27,40 +27,40 @@ export class ContrastCheckTrigger {
   }
 
   async modelAdded(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): Promise<void> {
-    this.pageLoadListeners.set(
+    this.#pageLoadListeners.set(
         resourceTreeModel,
-        resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.Load, this.pageLoaded, this));
-    this.frameAddedListeners.set(
+        resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.Load, this.#pageLoaded, this));
+    this.#frameAddedListeners.set(
         resourceTreeModel,
-        resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameAdded, this.frameAdded, this));
+        resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameAdded, this.#frameAdded, this));
   }
 
   modelRemoved(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
-    const pageLoadListener = this.pageLoadListeners.get(resourceTreeModel);
+    const pageLoadListener = this.#pageLoadListeners.get(resourceTreeModel);
     if (pageLoadListener) {
       Common.EventTarget.removeEventListeners([pageLoadListener]);
     }
-    const frameAddedListeners = this.frameAddedListeners.get(resourceTreeModel);
+    const frameAddedListeners = this.#frameAddedListeners.get(resourceTreeModel);
     if (frameAddedListeners) {
       Common.EventTarget.removeEventListeners([frameAddedListeners]);
     }
   }
 
-  private checkContrast(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
+  #checkContrast(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
     if (!Root.Runtime.experiments.isEnabled('contrastIssues')) {
       return;
     }
     resourceTreeModel.target().auditsAgent().invoke_checkContrast({});
   }
 
-  private pageLoaded(
-      event: Common.EventTarget
-          .EventTargetEvent<{resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel, loadTime: number}>): void {
+  #pageLoaded(event: Common.EventTarget
+                  .EventTargetEvent<{resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel, loadTime: number}>):
+      void {
     const {resourceTreeModel} = event.data;
-    this.checkContrast(resourceTreeModel);
+    this.#checkContrast(resourceTreeModel);
   }
 
-  private async frameAdded(event: Common.EventTarget.EventTargetEvent<SDK.ResourceTreeModel.ResourceTreeFrame>):
+  async #frameAdded(event: Common.EventTarget.EventTargetEvent<SDK.ResourceTreeModel.ResourceTreeFrame>):
       Promise<void> {
     if (!Root.Runtime.experiments.isEnabled('contrastIssues')) {
       return;
@@ -74,7 +74,7 @@ export class ContrastCheckTrigger {
     const response = await frame.resourceTreeModel().target().runtimeAgent().invoke_evaluate(
         {expression: 'document.readyState', returnByValue: true});
     if (response.result && response.result.value === 'complete') {
-      this.checkContrast(frame.resourceTreeModel());
+      this.#checkContrast(frame.resourceTreeModel());
     }
   }
 }

package/front_end/models/issues_manager/CorsIssue.ts

@@ -99,13 +99,13 @@ function getIssueCode(details: Protocol.Audits.CorsIssueDetails): IssueCode {
 }
 
 export class CorsIssue extends Issue<IssueCode> {
-  private issueDetails: Protocol.Audits.CorsIssueDetails;
+  #issueDetails: Protocol.Audits.CorsIssueDetails;
 
   constructor(
       issueDetails: Protocol.Audits.CorsIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel,
       issueId: Protocol.Audits.IssueId|undefined) {
     super(getIssueCode(issueDetails), issuesModel, issueId);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   getCategory(): IssueCategory {
@@ -113,11 +113,11 @@ export class CorsIssue extends Issue<IssueCode> {
   }
 
   details(): Protocol.Audits.CorsIssueDetails {
-    return this.issueDetails;
+    return this.#issueDetails;
   }
 
   getDescription(): MarkdownIssueDescription|null {
-    switch (getIssueCode(this.issueDetails)) {
+    switch (getIssueCode(this.#issueDetails)) {
       case IssueCode.InsecurePrivateNetwork:
         return {
           file: 'corsInsecurePrivateNetwork.md',
@@ -231,15 +231,15 @@ export class CorsIssue extends Issue<IssueCode> {
   }
 
   primaryKey(): string {
-    return JSON.stringify(this.issueDetails);
+    return JSON.stringify(this.#issueDetails);
   }
 
   getKind(): IssueKind {
-    if (this.issueDetails.isWarning &&
-        (this.issueDetails.corsErrorStatus.corsError === Protocol.Network.CorsError.InsecurePrivateNetwork ||
-         this.issueDetails.corsErrorStatus.corsError ===
+    if (this.#issueDetails.isWarning &&
+        (this.#issueDetails.corsErrorStatus.corsError === Protocol.Network.CorsError.InsecurePrivateNetwork ||
+         this.#issueDetails.corsErrorStatus.corsError ===
              Protocol.Network.CorsError.PreflightMissingAllowPrivateNetwork ||
-         this.issueDetails.corsErrorStatus.corsError ===
+         this.#issueDetails.corsErrorStatus.corsError ===
              Protocol.Network.CorsError.PreflightInvalidAllowPrivateNetwork)) {
       return IssueKind.BreakingChange;
     }

package/front_end/models/issues_manager/CrossOriginEmbedderPolicyIssue.ts

@@ -40,23 +40,23 @@ export function isCrossOriginEmbedderPolicyIssue(reason: Protocol.Audits.Blocked
 }
 
 export class CrossOriginEmbedderPolicyIssue extends Issue {
-  private issueDetails: Protocol.Audits.BlockedByResponseIssueDetails;
+  #issueDetails: Protocol.Audits.BlockedByResponseIssueDetails;
 
   constructor(issueDetails: Protocol.Audits.BlockedByResponseIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel) {
     super(`CrossOriginEmbedderPolicyIssue::${issueDetails.reason}`, issuesModel);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   primaryKey(): string {
-    return `${this.code()}-(${this.issueDetails.request.requestId})`;
+    return `${this.code()}-(${this.#issueDetails.request.requestId})`;
   }
 
   getBlockedByResponseDetails(): Iterable<Protocol.Audits.BlockedByResponseIssueDetails> {
-    return [this.issueDetails];
+    return [this.#issueDetails];
   }
 
   requests(): Iterable<Protocol.Audits.AffectedRequest> {
-    return [this.issueDetails.request];
+    return [this.#issueDetails.request];
   }
 
   getCategory(): IssueCategory {

package/front_end/models/issues_manager/DeprecationIssue.ts

@@ -13,11 +13,11 @@ export const enum IssueCode {
 }
 
 export class DeprecationIssue extends Issue<IssueCode> {
-  private issueDetails: Protocol.Audits.DeprecationIssueDetails;
+  #issueDetails: Protocol.Audits.DeprecationIssueDetails;
 
   constructor(issueDetails: Protocol.Audits.DeprecationIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel) {
     super(IssueCode.DeprecationIssue, issuesModel);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   getCategory(): IssueCategory {
@@ -25,7 +25,7 @@ export class DeprecationIssue extends Issue<IssueCode> {
   }
 
   details(): Protocol.Audits.DeprecationIssueDetails {
-    return this.issueDetails;
+    return this.#issueDetails;
   }
 
   getDescription(): MarkdownIssueDescription|null {
@@ -34,21 +34,21 @@ export class DeprecationIssue extends Issue<IssueCode> {
       substitutions: new Map([
         // TODO(crbug.com/1264960): Re-work format to add i18n support per:
         // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/public/devtools_protocol/README.md
-        ['PLACEHOLDER_message', String(this.issueDetails.message)],
+        ['PLACEHOLDER_message', String(this.#issueDetails.message)],
       ]),
       links: [],
     };
   }
 
   sources(): Iterable<Protocol.Audits.SourceCodeLocation> {
-    if (this.issueDetails.sourceCodeLocation) {
-      return [this.issueDetails.sourceCodeLocation];
+    if (this.#issueDetails.sourceCodeLocation) {
+      return [this.#issueDetails.sourceCodeLocation];
     }
     return [];
   }
 
   primaryKey(): string {
-    return JSON.stringify(this.issueDetails);
+    return JSON.stringify(this.#issueDetails);
   }
 
   getKind(): IssueKind {

package/front_end/models/issues_manager/GenericIssue.ts

@@ -20,7 +20,7 @@ const str_ = i18n.i18n.registerUIStrings('models/issues_manager/GenericIssue.ts'
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
 
 export class GenericIssue extends Issue {
-  private issueDetails: Protocol.Audits.GenericIssueDetails;
+  #issueDetails: Protocol.Audits.GenericIssueDetails;
 
   constructor(
       issueDetails: Protocol.Audits.GenericIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel,
@@ -30,7 +30,7 @@ export class GenericIssue extends Issue {
       issueDetails.errorType,
     ].join('::');
     super(issueCode, issuesModel, issueId);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   getCategory(): IssueCategory {
@@ -38,11 +38,11 @@ export class GenericIssue extends Issue {
   }
 
   primaryKey(): string {
-    return `${this.code()}-(${this.issueDetails.frameId})`;
+    return `${this.code()}-(${this.#issueDetails.frameId})`;
   }
 
   getDescription(): MarkdownIssueDescription|null {
-    const description = issueDescriptions.get(this.issueDetails.errorType);
+    const description = issueDescriptions.get(this.#issueDetails.errorType);
     if (!description) {
       return null;
     }
@@ -50,7 +50,7 @@ export class GenericIssue extends Issue {
   }
 
   details(): Protocol.Audits.GenericIssueDetails {
-    return this.issueDetails;
+    return this.#issueDetails;
   }
 
   getKind(): IssueKind {

package/front_end/models/issues_manager/HeavyAdIssue.ts

@@ -19,20 +19,20 @@ const str_ = i18n.i18n.registerUIStrings('models/issues_manager/HeavyAdIssue.ts'
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class HeavyAdIssue extends Issue {
-  private issueDetails: Protocol.Audits.HeavyAdIssueDetails;
+  #issueDetails: Protocol.Audits.HeavyAdIssueDetails;
 
   constructor(issueDetails: Protocol.Audits.HeavyAdIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel) {
     const umaCode = [Protocol.Audits.InspectorIssueCode.HeavyAdIssue, issueDetails.reason].join('::');
     super({code: Protocol.Audits.InspectorIssueCode.HeavyAdIssue, umaCode}, issuesModel);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   details(): Protocol.Audits.HeavyAdIssueDetails {
-    return this.issueDetails;
+    return this.#issueDetails;
   }
 
   primaryKey(): string {
-    return `${Protocol.Audits.InspectorIssueCode.HeavyAdIssue}-${JSON.stringify(this.issueDetails)}`;
+    return `${Protocol.Audits.InspectorIssueCode.HeavyAdIssue}-${JSON.stringify(this.#issueDetails)}`;
   }
 
   getDescription(): MarkdownIssueDescription {
@@ -52,7 +52,7 @@ export class HeavyAdIssue extends Issue {
   }
 
   getKind(): IssueKind {
-    switch (this.issueDetails.resolution) {
+    switch (this.#issueDetails.resolution) {
       case Protocol.Audits.HeavyAdResolutionStatus.HeavyAdBlocked:
         return IssueKind.PageError;
       case Protocol.Audits.HeavyAdResolutionStatus.HeavyAdWarning:

package/front_end/models/issues_manager/Issue.ts

@@ -123,23 +123,23 @@ export interface AffectedElement {
 }
 
 export abstract class Issue<IssueCode extends string = string> {
-  private issueCode: IssueCode;
-  private issuesModel: SDK.IssuesModel.IssuesModel|null;
+  #issueCode: IssueCode;
+  #issuesModel: SDK.IssuesModel.IssuesModel|null;
   protected issueId: Protocol.Audits.IssueId|undefined = undefined;
-  private hidden: boolean;
+  #hidden: boolean;
 
   constructor(
       code: IssueCode|{code: IssueCode, umaCode: string}, issuesModel: SDK.IssuesModel.IssuesModel|null = null,
       issueId?: Protocol.Audits.IssueId) {
-    this.issueCode = typeof code === 'object' ? code.code : code;
-    this.issuesModel = issuesModel;
+    this.#issueCode = typeof code === 'object' ? code.code : code;
+    this.#issuesModel = issuesModel;
     this.issueId = issueId;
     Host.userMetrics.issueCreated(typeof code === 'string' ? code : code.umaCode);
-    this.hidden = false;
+    this.#hidden = false;
   }
 
   code(): IssueCode {
-    return this.issueCode;
+    return this.#issueCode;
   }
 
   abstract primaryKey(): string;
@@ -184,7 +184,7 @@ export abstract class Issue<IssueCode extends string = string> {
    * The model might be unavailable or belong to a target that has already been disposed.
    */
   model(): SDK.IssuesModel.IssuesModel|null {
-    return this.issuesModel;
+    return this.#issuesModel;
   }
 
   isCausedByThirdParty(): boolean {
@@ -196,11 +196,11 @@ export abstract class Issue<IssueCode extends string = string> {
   }
 
   isHidden(): boolean {
-    return this.hidden;
+    return this.#hidden;
   }
 
   setHidden(hidden: boolean): void {
-    this.hidden = hidden;
+    this.#hidden = hidden;
   }
 }
 

package/front_end/models/issues_manager/IssueResolver.ts

@@ -13,19 +13,19 @@ import type {IssueAddedEvent} from './IssuesManager.js';
   * A class that facilitates resolving an issueId to an issue. See `ResolverBase` for more info.
   */
 export class IssueResolver extends Common.ResolverBase.ResolverBase<Protocol.Audits.IssueId, Issue> {
-  private issuesListener: Common.EventTarget.EventDescriptor|null = null;
-  private issuesManager: IssuesManager;
+  #issuesListener: Common.EventTarget.EventDescriptor|null = null;
+  #issuesManager: IssuesManager;
 
   constructor(issuesManager: IssuesManager = IssuesManager.instance()) {
     super();
-    this.issuesManager = issuesManager;
+    this.#issuesManager = issuesManager;
   }
 
   protected override getForId(id: Protocol.Audits.IssueId): Issue|null {
-    return this.issuesManager.getIssueById(id) || null;
+    return this.#issuesManager.getIssueById(id) || null;
   }
 
-  private onIssueAdded(event: Common.EventTarget.EventTargetEvent<IssueAddedEvent>): void {
+  #onIssueAdded(event: Common.EventTarget.EventTargetEvent<IssueAddedEvent>): void {
     const {issue} = event.data;
     const id = issue.getIssueId();
     if (id) {
@@ -34,17 +34,18 @@ export class IssueResolver extends Common.ResolverBase.ResolverBase<Protocol.Aud
   }
 
   protected override startListening(): void {
-    if (this.issuesListener) {
+    if (this.#issuesListener) {
       return;
     }
-    this.issuesListener = this.issuesManager.addEventListener(IssueManagerEvents.IssueAdded, this.onIssueAdded, this);
+    this.#issuesListener =
+        this.#issuesManager.addEventListener(IssueManagerEvents.IssueAdded, this.#onIssueAdded, this);
   }
 
   protected override stopListening(): void {
-    if (!this.issuesListener) {
+    if (!this.#issuesListener) {
       return;
     }
-    Common.EventTarget.removeEventListeners([this.issuesListener]);
-    this.issuesListener = null;
+    Common.EventTarget.removeEventListeners([this.#issuesListener]);
+    this.#issuesListener = null;
   }
 }

package/front_end/models/issues_manager/IssuesManager.ts

@@ -160,30 +160,30 @@ export function getHideIssueByCodeSetting(): Common.Settings.Setting<HideIssueMe
  */
 export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDK.TargetManager.SDKModelObserver<SDK.IssuesModel.IssuesModel> {
-  private eventListeners = new WeakMap<SDK.IssuesModel.IssuesModel, Common.EventTarget.EventDescriptor>();
-  private allIssues = new Map<string, Issue>();
-  private filteredIssues = new Map<string, Issue>();
-  private issueCounts = new Map<IssueKind, number>();
-  private hiddenIssueCount = new Map<IssueKind, number>();
-  private hasSeenTopFrameNavigated = false;
-  private sourceFrameIssuesManager = new SourceFrameIssuesManager(this);
-  private issuesById: Map<string, Issue> = new Map();
+  #eventListeners = new WeakMap<SDK.IssuesModel.IssuesModel, Common.EventTarget.EventDescriptor>();
+  #allIssues = new Map<string, Issue>();
+  #filteredIssues = new Map<string, Issue>();
+  #issueCounts = new Map<IssueKind, number>();
+  #hiddenIssueCount = new Map<IssueKind, number>();
+  #hasSeenTopFrameNavigated = false;
+  #issuesById: Map<string, Issue> = new Map();
 
   constructor(
       private readonly showThirdPartyIssuesSetting?: Common.Settings.Setting<boolean>,
       private readonly hideIssueSetting?: Common.Settings.Setting<HideIssueMenuSetting>) {
     super();
+    new SourceFrameIssuesManager(this);
     SDK.TargetManager.TargetManager.instance().observeModels(SDK.IssuesModel.IssuesModel, this);
     SDK.FrameManager.FrameManager.instance().addEventListener(
-        SDK.FrameManager.Events.TopFrameNavigated, this.onTopFrameNavigated, this);
+        SDK.FrameManager.Events.TopFrameNavigated, this.#onTopFrameNavigated, this);
     SDK.FrameManager.FrameManager.instance().addEventListener(
-        SDK.FrameManager.Events.FrameAddedToTarget, this.onFrameAddedToTarget, this);
+        SDK.FrameManager.Events.FrameAddedToTarget, this.#onFrameAddedToTarget, this);
 
     // issueFilter uses the 'showThirdPartyIssues' setting. Clients of IssuesManager need
     // a full update when the setting changes to get an up-to-date issues list.
-    this.showThirdPartyIssuesSetting?.addChangeListener(() => this.updateFilteredIssues());
+    this.showThirdPartyIssuesSetting?.addChangeListener(() => this.#updateFilteredIssues());
     if (Root.Runtime.experiments.isEnabled('hideIssuesFeature')) {
-      this.hideIssueSetting?.addChangeListener(() => this.updateFilteredIssues());
+      this.hideIssueSetting?.addChangeListener(() => this.#updateFilteredIssues());
     }
   }
 
@@ -210,48 +210,48 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
    * during navigation.
    */
   reloadForAccurateInformationRequired(): boolean {
-    return !this.hasSeenTopFrameNavigated;
+    return !this.#hasSeenTopFrameNavigated;
   }
 
-  private onTopFrameNavigated(
-      event: Common.EventTarget.EventTargetEvent<{frame: SDK.ResourceTreeModel.ResourceTreeFrame}>): void {
+  #onTopFrameNavigated(event: Common.EventTarget.EventTargetEvent<{frame: SDK.ResourceTreeModel.ResourceTreeFrame}>):
+      void {
     const {frame} = event.data;
     const keptIssues = new Map<string, Issue>();
-    for (const [key, issue] of this.allIssues.entries()) {
+    for (const [key, issue] of this.#allIssues.entries()) {
       if (issue.isAssociatedWithRequestId(frame.loaderId)) {
         keptIssues.set(key, issue);
       }
     }
-    this.allIssues = keptIssues;
-    this.hasSeenTopFrameNavigated = true;
-    this.updateFilteredIssues();
+    this.#allIssues = keptIssues;
+    this.#hasSeenTopFrameNavigated = true;
+    this.#updateFilteredIssues();
   }
 
-  private onFrameAddedToTarget(
-      event: Common.EventTarget.EventTargetEvent<{frame: SDK.ResourceTreeModel.ResourceTreeFrame}>): void {
+  #onFrameAddedToTarget(event: Common.EventTarget.EventTargetEvent<{frame: SDK.ResourceTreeModel.ResourceTreeFrame}>):
+      void {
     const {frame} = event.data;
     // Determining third-party status usually requires the registered domain of the top frame.
     // When DevTools is opened after navigation has completed, issues may be received
     // before the top frame is available. Thus, we trigger a recalcuation of third-party-ness
     // when we attach to the top frame.
     if (frame.isTopFrame()) {
-      this.updateFilteredIssues();
+      this.#updateFilteredIssues();
     }
   }
 
   modelAdded(issuesModel: SDK.IssuesModel.IssuesModel): void {
-    const listener = issuesModel.addEventListener(SDK.IssuesModel.Events.IssueAdded, this.onIssueAddedEvent, this);
-    this.eventListeners.set(issuesModel, listener);
+    const listener = issuesModel.addEventListener(SDK.IssuesModel.Events.IssueAdded, this.#onIssueAddedEvent, this);
+    this.#eventListeners.set(issuesModel, listener);
   }
 
   modelRemoved(issuesModel: SDK.IssuesModel.IssuesModel): void {
-    const listener = this.eventListeners.get(issuesModel);
+    const listener = this.#eventListeners.get(issuesModel);
     if (listener) {
       Common.EventTarget.removeEventListeners([listener]);
     }
   }
 
-  private onIssueAddedEvent(event: Common.EventTarget.EventTargetEvent<SDK.IssuesModel.IssueAddedEvent>): void {
+  #onIssueAddedEvent(event: Common.EventTarget.EventTargetEvent<SDK.IssuesModel.IssueAddedEvent>): void {
     const {issuesModel, inspectorIssue} = event.data;
     const issues = createIssuesFromProtocolIssue(issuesModel, inspectorIssue);
     for (const issue of issues) {
@@ -265,25 +265,25 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
       return;
     }
     const primaryKey = issue.primaryKey();
-    if (this.allIssues.has(primaryKey)) {
+    if (this.#allIssues.has(primaryKey)) {
       return;
     }
-    this.allIssues.set(primaryKey, issue);
+    this.#allIssues.set(primaryKey, issue);
 
-    if (this.issueFilter(issue)) {
-      this.filteredIssues.set(primaryKey, issue);
-      this.issueCounts.set(issue.getKind(), 1 + (this.issueCounts.get(issue.getKind()) || 0));
+    if (this.#issueFilter(issue)) {
+      this.#filteredIssues.set(primaryKey, issue);
+      this.#issueCounts.set(issue.getKind(), 1 + (this.#issueCounts.get(issue.getKind()) || 0));
       const issueId = issue.getIssueId();
       if (issueId) {
-        this.issuesById.set(issueId, issue);
+        this.#issuesById.set(issueId, issue);
       }
       const values = this.hideIssueSetting?.get();
       const hideIssuesFeature = Root.Runtime.experiments.isEnabled('hideIssuesFeature');
       if (hideIssuesFeature) {
-        this.updateIssueHiddenStatus(issue, values);
+        this.#updateIssueHiddenStatus(issue, values);
       }
       if (issue.isHidden()) {
-        this.hiddenIssueCount.set(issue.getKind(), 1 + (this.hiddenIssueCount.get(issue.getKind()) || 0));
+        this.#hiddenIssueCount.set(issue.getKind(), 1 + (this.#hiddenIssueCount.get(issue.getKind()) || 0));
       }
       this.dispatchEventToListeners(Events.IssueAdded, {issuesModel, issue});
     }
@@ -293,36 +293,36 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   }
 
   issues(): Iterable<Issue> {
-    return this.filteredIssues.values();
+    return this.#filteredIssues.values();
   }
 
   numberOfIssues(kind?: IssueKind): number {
     if (kind) {
-      return (this.issueCounts.get(kind) ?? 0) - this.numberOfHiddenIssues(kind);
+      return (this.#issueCounts.get(kind) ?? 0) - this.numberOfHiddenIssues(kind);
     }
-    return this.filteredIssues.size - this.numberOfHiddenIssues();
+    return this.#filteredIssues.size - this.numberOfHiddenIssues();
   }
 
   numberOfHiddenIssues(kind?: IssueKind): number {
     if (kind) {
-      return this.hiddenIssueCount.get(kind) ?? 0;
+      return this.#hiddenIssueCount.get(kind) ?? 0;
     }
     let count = 0;
-    for (const num of this.hiddenIssueCount.values()) {
+    for (const num of this.#hiddenIssueCount.values()) {
       count += num;
     }
     return count;
   }
 
   numberOfAllStoredIssues(): number {
-    return this.allIssues.size;
+    return this.#allIssues.size;
   }
 
-  private issueFilter(issue: Issue): boolean {
+  #issueFilter(issue: Issue): boolean {
     return this.showThirdPartyIssuesSetting?.get() || !issue.isCausedByThirdParty();
   }
 
-  private updateIssueHiddenStatus(issue: Issue, values: HideIssueMenuSetting|undefined): void {
+  #updateIssueHiddenStatus(issue: Issue, values: HideIssueMenuSetting|undefined): void {
     const code = issue.code();
     // All issues are hidden via their code.
     // For hiding we check whether the issue code is present and has a value of IssueStatus.Hidden
@@ -340,26 +340,26 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     }
   }
 
-  private updateFilteredIssues(): void {
-    this.filteredIssues.clear();
-    this.issueCounts.clear();
-    this.issuesById.clear();
-    this.hiddenIssueCount.clear();
+  #updateFilteredIssues(): void {
+    this.#filteredIssues.clear();
+    this.#issueCounts.clear();
+    this.#issuesById.clear();
+    this.#hiddenIssueCount.clear();
     const values = this.hideIssueSetting?.get();
     const hideIssuesFeature = Root.Runtime.experiments.isEnabled('hideIssuesFeature');
-    for (const [key, issue] of this.allIssues) {
-      if (this.issueFilter(issue)) {
+    for (const [key, issue] of this.#allIssues) {
+      if (this.#issueFilter(issue)) {
         if (hideIssuesFeature) {
-          this.updateIssueHiddenStatus(issue, values);
+          this.#updateIssueHiddenStatus(issue, values);
         }
-        this.filteredIssues.set(key, issue);
-        this.issueCounts.set(issue.getKind(), 1 + (this.issueCounts.get(issue.getKind()) ?? 0));
+        this.#filteredIssues.set(key, issue);
+        this.#issueCounts.set(issue.getKind(), 1 + (this.#issueCounts.get(issue.getKind()) ?? 0));
         if (issue.isHidden()) {
-          this.hiddenIssueCount.set(issue.getKind(), 1 + (this.hiddenIssueCount.get(issue.getKind()) || 0));
+          this.#hiddenIssueCount.set(issue.getKind(), 1 + (this.#hiddenIssueCount.get(issue.getKind()) || 0));
         }
         const issueId = issue.getIssueId();
         if (issueId) {
-          this.issuesById.set(issueId, issue);
+          this.#issuesById.set(issueId, issue);
         }
       }
     }
@@ -368,14 +368,14 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   }
 
   unhideAllIssues(): void {
-    for (const issue of this.allIssues.values()) {
+    for (const issue of this.#allIssues.values()) {
       issue.setHidden(false);
     }
     this.hideIssueSetting?.set(defaultHideIssueByCodeSetting());
   }
 
   getIssueById(id: string): Issue|undefined {
-    return this.issuesById.get(id);
+    return this.#issuesById.get(id);
   }
 }
 

package/front_end/models/issues_manager/LowTextContrastIssue.ts

@@ -19,17 +19,17 @@ const str_ = i18n.i18n.registerUIStrings('models/issues_manager/LowTextContrastI
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class LowTextContrastIssue extends Issue {
-  private issueDetails: Protocol.Audits.LowTextContrastIssueDetails;
+  #issueDetails: Protocol.Audits.LowTextContrastIssueDetails;
 
   constructor(issueDetails: Protocol.Audits.LowTextContrastIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel) {
     super('LowTextContrastIssue', issuesModel);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   primaryKey(): string {
     // We intend to keep only one issue per element so other issues for the element will be discarded even
     // if the issue content is slightly different.
-    return `${this.code()}-(${this.issueDetails.violatingNodeId})`;
+    return `${this.code()}-(${this.#issueDetails.violatingNodeId})`;
   }
 
   getCategory(): IssueCategory {
@@ -37,7 +37,7 @@ export class LowTextContrastIssue extends Issue {
   }
 
   details(): Protocol.Audits.LowTextContrastIssueDetails {
-    return this.issueDetails;
+    return this.#issueDetails;
   }
 
   getDescription(): MarkdownIssueDescription {