chrome-devtools-frontend 1.0.951864 → 1.0.952284

package/front_end/entrypoints/main/MainImpl.ts

@@ -114,7 +114,7 @@ const str_ = i18n.i18n.registerUIStrings('entrypoints/main/MainImpl.ts', UIStrin
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class MainImpl {
-  private lateInitDonePromise!: Promise<void>;
+  #lateInitDonePromise!: Promise<void>;
 
   constructor() {
     MainImpl.instanceForTest = this;
@@ -606,12 +606,12 @@ export class MainImpl {
         Common.Settings.Settings.instance().moduleSetting(setting).addChangeListener(changeListener);
       }
     }
-    this.lateInitDonePromise = Promise.all(promises).then(() => undefined);
+    this.#lateInitDonePromise = Promise.all(promises).then(() => undefined);
     MainImpl.timeEnd('Main._lateInitialization');
   }
 
   lateInitDonePromiseForTest(): Promise<void>|null {
-    return this.lateInitDonePromise;
+    return this.#lateInitDonePromise;
   }
 
   private registerMessageSinkListener(): void {
@@ -769,11 +769,11 @@ export class SearchActionDelegate implements UI.ActionRegistration.ActionDelegat
 let mainMenuItemInstance: MainMenuItem;
 
 export class MainMenuItem implements UI.Toolbar.Provider {
-  private readonly itemInternal: UI.Toolbar.ToolbarMenuButton;
+  readonly #itemInternal: UI.Toolbar.ToolbarMenuButton;
   constructor() {
-    this.itemInternal = new UI.Toolbar.ToolbarMenuButton(this.handleContextMenu.bind(this), true);
-    this.itemInternal.element.classList.add('main-menu');
-    this.itemInternal.setTitle(i18nString(UIStrings.customizeAndControlDevtools));
+    this.#itemInternal = new UI.Toolbar.ToolbarMenuButton(this.handleContextMenu.bind(this), true);
+    this.#itemInternal.element.classList.add('main-menu');
+    this.#itemInternal.setTitle(i18nString(UIStrings.customizeAndControlDevtools));
   }
 
   static instance(opts: {
@@ -788,7 +788,7 @@ export class MainMenuItem implements UI.Toolbar.Provider {
   }
 
   item(): UI.Toolbar.ToolbarItem|null {
-    return this.itemInternal;
+    return this.#itemInternal;
   }
 
   private handleContextMenu(contextMenu: UI.ContextMenu.ContextMenu): void {
@@ -853,7 +853,7 @@ export class MainMenuItem implements UI.Toolbar.Provider {
       contextMenu.headerSection().appendCustomItem(dockItemElement);
     }
 
-    const button = (this.itemInternal.element as HTMLButtonElement);
+    const button = (this.#itemInternal.element as HTMLButtonElement);
 
     function setDockSide(side: UI.DockController.DockState): void {
       UI.DockController.DockController.instance().once(UI.DockController.Events.AfterDockSideChanged).then(() => {
@@ -926,10 +926,10 @@ export class MainMenuItem implements UI.Toolbar.Provider {
 let settingsButtonProviderInstance: SettingsButtonProvider;
 
 export class SettingsButtonProvider implements UI.Toolbar.Provider {
-  private readonly settingsButton: UI.Toolbar.ToolbarButton;
+  readonly #settingsButton: UI.Toolbar.ToolbarButton;
   private constructor() {
     const settingsActionId = 'settings.show';
-    this.settingsButton =
+    this.#settingsButton =
         UI.Toolbar.Toolbar.createActionButtonForId(settingsActionId, {showLabel: false, userActionCode: undefined});
   }
 
@@ -945,7 +945,7 @@ export class SettingsButtonProvider implements UI.Toolbar.Provider {
   }
 
   item(): UI.Toolbar.ToolbarItem|null {
-    return this.settingsButton;
+    return this.#settingsButton;
   }
 }
 

package/front_end/entrypoints/node_app/NodeConnectionsPanel.ts

@@ -38,8 +38,8 @@ const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 let nodeConnectionsPanelInstance: NodeConnectionsPanel;
 
 export class NodeConnectionsPanel extends UI.Panel.Panel {
-  private config!: Adb.Config;
-  private readonly networkDiscoveryView: NodeConnectionsView;
+  #config!: Adb.Config;
+  readonly #networkDiscoveryView: NodeConnectionsView;
   private constructor() {
     super('node-connection');
 
@@ -60,11 +60,11 @@ export class NodeConnectionsPanel extends UI.Panel.Panel {
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.setDevicesUpdatesEnabled(false);
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.setDevicesUpdatesEnabled(true);
 
-    this.networkDiscoveryView = new NodeConnectionsView(config => {
-      this.config.networkDiscoveryConfig = config;
-      Host.InspectorFrontendHost.InspectorFrontendHostInstance.setDevicesDiscoveryConfig(this.config);
+    this.#networkDiscoveryView = new NodeConnectionsView(config => {
+      this.#config.networkDiscoveryConfig = config;
+      Host.InspectorFrontendHost.InspectorFrontendHostInstance.setDevicesDiscoveryConfig(this.#config);
     });
-    this.networkDiscoveryView.show(container);
+    this.#networkDiscoveryView.show(container);
   }
 
   static instance(opts: {
@@ -79,8 +79,8 @@ export class NodeConnectionsPanel extends UI.Panel.Panel {
   }
 
   private devicesDiscoveryConfigChanged({data: config}: Common.EventTarget.EventTargetEvent<Adb.Config>): void {
-    this.config = config;
-    this.networkDiscoveryView.discoveryConfigChanged(this.config.networkDiscoveryConfig);
+    this.#config = config;
+    this.#networkDiscoveryView.discoveryConfigChanged(this.#config.networkDiscoveryConfig);
   }
   wasShown(): void {
     super.wasShown();
@@ -89,15 +89,15 @@ export class NodeConnectionsPanel extends UI.Panel.Panel {
 }
 
 export class NodeConnectionsView extends UI.Widget.VBox implements UI.ListWidget.Delegate<Adb.PortForwardingRule> {
-  private readonly callback: (arg0: Adb.NetworkDiscoveryConfig) => void;
-  private readonly list: UI.ListWidget.ListWidget<Adb.PortForwardingRule>;
-  private editor: UI.ListWidget.Editor<Adb.PortForwardingRule>|null;
-  private networkDiscoveryConfig: {
+  readonly #callback: (arg0: Adb.NetworkDiscoveryConfig) => void;
+  readonly #list: UI.ListWidget.ListWidget<Adb.PortForwardingRule>;
+  #editor: UI.ListWidget.Editor<Adb.PortForwardingRule>|null;
+  #networkDiscoveryConfig: {
     address: string,
   }[];
   constructor(callback: (arg0: Adb.NetworkDiscoveryConfig) => void) {
     super();
-    this.callback = callback;
+    this.#callback = callback;
     this.element.classList.add('network-discovery-view');
 
     const networkDiscoveryFooter = this.element.createChild('div', 'network-discovery-footer');
@@ -106,42 +106,42 @@ export class NodeConnectionsView extends UI.Widget.VBox implements UI.ListWidget
     networkDiscoveryFooter.appendChild(
         i18n.i18n.getFormatLocalizedString(str_, UIStrings.specifyNetworkEndpointAnd, {PH1: documentationLink}));
 
-    this.list = new UI.ListWidget.ListWidget(this);
+    this.#list = new UI.ListWidget.ListWidget(this);
 
-    this.list.element.classList.add('network-discovery-list');
+    this.#list.element.classList.add('network-discovery-list');
     const placeholder = document.createElement('div');
     placeholder.classList.add('network-discovery-list-empty');
     placeholder.textContent = i18nString(UIStrings.noConnectionsSpecified);
-    this.list.setEmptyPlaceholder(placeholder);
-    this.list.show(this.element);
-    this.editor = null;
+    this.#list.setEmptyPlaceholder(placeholder);
+    this.#list.show(this.element);
+    this.#editor = null;
 
     const addButton = UI.UIUtils.createTextButton(
         i18nString(UIStrings.addConnection), this.addNetworkTargetButtonClicked.bind(this), 'add-network-target-button',
         true /* primary */);
     this.element.appendChild(addButton);
 
-    this.networkDiscoveryConfig = [];
+    this.#networkDiscoveryConfig = [];
 
     this.element.classList.add('node-frontend');
   }
 
   private update(): void {
-    const config = this.networkDiscoveryConfig.map(item => item.address);
-    this.callback.call(null, config);
+    const config = this.#networkDiscoveryConfig.map(item => item.address);
+    this.#callback.call(null, config);
   }
 
   private addNetworkTargetButtonClicked(): void {
-    this.list.addNewItem(this.networkDiscoveryConfig.length, {address: '', port: ''});
+    this.#list.addNewItem(this.#networkDiscoveryConfig.length, {address: '', port: ''});
   }
 
   discoveryConfigChanged(networkDiscoveryConfig: Adb.NetworkDiscoveryConfig): void {
-    this.networkDiscoveryConfig = [];
-    this.list.clear();
+    this.#networkDiscoveryConfig = [];
+    this.#list.clear();
     for (const address of networkDiscoveryConfig) {
       const item = {address: address, port: ''};
-      this.networkDiscoveryConfig.push(item);
-      this.list.appendItem(item, true);
+      this.#networkDiscoveryConfig.push(item);
+      this.#list.appendItem(item, true);
     }
   }
 
@@ -153,15 +153,15 @@ export class NodeConnectionsView extends UI.Widget.VBox implements UI.ListWidget
   }
 
   removeItemRequested(rule: Adb.PortForwardingRule, index: number): void {
-    this.networkDiscoveryConfig.splice(index, 1);
-    this.list.removeItem(index);
+    this.#networkDiscoveryConfig.splice(index, 1);
+    this.#list.removeItem(index);
     this.update();
   }
 
   commitEdit(rule: Adb.PortForwardingRule, editor: UI.ListWidget.Editor<Adb.PortForwardingRule>, isNew: boolean): void {
     rule.address = editor.control('address').value.trim();
     if (isNew) {
-      this.networkDiscoveryConfig.push(rule);
+      this.#networkDiscoveryConfig.push(rule);
     }
     this.update();
   }
@@ -173,12 +173,12 @@ export class NodeConnectionsView extends UI.Widget.VBox implements UI.ListWidget
   }
 
   private createEditor(): UI.ListWidget.Editor<Adb.PortForwardingRule> {
-    if (this.editor) {
-      return this.editor;
+    if (this.#editor) {
+      return this.#editor;
     }
 
     const editor = new UI.ListWidget.Editor<Adb.PortForwardingRule>();
-    this.editor = editor;
+    this.#editor = editor;
     const content = editor.contentElement();
     const fields = content.createChild('div', 'network-discovery-edit-row');
     const input =
@@ -204,6 +204,6 @@ export class NodeConnectionsView extends UI.Widget.VBox implements UI.ListWidget
   }
   wasShown(): void {
     super.wasShown();
-    this.list.registerCSSFiles([nodeConnectionsPanelStyles]);
+    this.#list.registerCSSFiles([nodeConnectionsPanelStyles]);
   }
 }

package/front_end/entrypoints/node_app/NodeMain.ts

@@ -46,21 +46,21 @@ export class NodeMainImpl implements Common.Runnable.Runnable {
 }
 
 export class NodeChildTargetManager extends SDK.SDKModel.SDKModel<void> implements ProtocolProxyApi.TargetDispatcher {
-  private readonly targetManager: SDK.TargetManager.TargetManager;
-  private readonly parentTarget: SDK.Target.Target;
-  private readonly targetAgent: ProtocolProxyApi.TargetApi;
-  private readonly childTargets: Map<Protocol.Target.SessionID, SDK.Target.Target>;
-  private readonly childConnections: Map<string, NodeConnection>;
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #parentTarget: SDK.Target.Target;
+  readonly #targetAgent: ProtocolProxyApi.TargetApi;
+  readonly #childTargets: Map<Protocol.Target.SessionID, SDK.Target.Target>;
+  readonly #childConnections: Map<string, NodeConnection>;
   constructor(parentTarget: SDK.Target.Target) {
     super(parentTarget);
-    this.targetManager = parentTarget.targetManager();
-    this.parentTarget = parentTarget;
-    this.targetAgent = parentTarget.targetAgent();
-    this.childTargets = new Map();
-    this.childConnections = new Map();
+    this.#targetManager = parentTarget.targetManager();
+    this.#parentTarget = parentTarget;
+    this.#targetAgent = parentTarget.targetAgent();
+    this.#childTargets = new Map();
+    this.#childConnections = new Map();
 
     parentTarget.registerTargetDispatcher(this);
-    this.targetAgent.invoke_setDiscoverTargets({discover: true});
+    this.#targetAgent.invoke_setDiscoverTargets({discover: true});
 
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
         Host.InspectorFrontendHostAPI.Events.DevicesDiscoveryConfigChanged, this.devicesDiscoveryConfigChanged, this);
@@ -77,21 +77,21 @@ export class NodeChildTargetManager extends SDK.SDKModel.SDKModel<void> implemen
         locations.push({host: parts[0], port: port});
       }
     }
-    this.targetAgent.invoke_setRemoteLocations({locations});
+    this.#targetAgent.invoke_setRemoteLocations({locations});
   }
 
   dispose(): void {
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.removeEventListener(
         Host.InspectorFrontendHostAPI.Events.DevicesDiscoveryConfigChanged, this.devicesDiscoveryConfigChanged, this);
 
-    for (const sessionId of this.childTargets.keys()) {
+    for (const sessionId of this.#childTargets.keys()) {
       this.detachedFromTarget({sessionId});
     }
   }
 
   targetCreated({targetInfo}: Protocol.Target.TargetCreatedEvent): void {
     if (targetInfo.type === 'node' && !targetInfo.attached) {
-      this.targetAgent.invoke_attachToTarget({targetId: targetInfo.targetId, flatten: false});
+      this.#targetAgent.invoke_attachToTarget({targetId: targetInfo.targetId, flatten: false});
     }
   }
 
@@ -103,25 +103,25 @@ export class NodeChildTargetManager extends SDK.SDKModel.SDKModel<void> implemen
 
   attachedToTarget({sessionId, targetInfo}: Protocol.Target.AttachedToTargetEvent): void {
     const name = i18nString(UIStrings.nodejsS, {PH1: targetInfo.url});
-    const connection = new NodeConnection(this.targetAgent, sessionId);
-    this.childConnections.set(sessionId, connection);
-    const target = this.targetManager.createTarget(
-        targetInfo.targetId, name, SDK.Target.Type.Node, this.parentTarget, undefined, undefined, connection);
-    this.childTargets.set(sessionId, target);
+    const connection = new NodeConnection(this.#targetAgent, sessionId);
+    this.#childConnections.set(sessionId, connection);
+    const target = this.#targetManager.createTarget(
+        targetInfo.targetId, name, SDK.Target.Type.Node, this.#parentTarget, undefined, undefined, connection);
+    this.#childTargets.set(sessionId, target);
     target.runtimeAgent().invoke_runIfWaitingForDebugger();
   }
 
   detachedFromTarget({sessionId}: Protocol.Target.DetachedFromTargetEvent): void {
-    const childTarget = this.childTargets.get(sessionId);
+    const childTarget = this.#childTargets.get(sessionId);
     if (childTarget) {
       childTarget.dispose('target terminated');
     }
-    this.childTargets.delete(sessionId);
-    this.childConnections.delete(sessionId);
+    this.#childTargets.delete(sessionId);
+    this.#childConnections.delete(sessionId);
   }
 
   receivedMessageFromTarget({sessionId, message}: Protocol.Target.ReceivedMessageFromTargetEvent): void {
-    const connection = this.childConnections.get(sessionId);
+    const connection = this.#childConnections.get(sessionId);
     const onMessage = connection ? connection.onMessage : null;
     if (onMessage) {
       onMessage.call(null, message);
@@ -133,15 +133,15 @@ export class NodeChildTargetManager extends SDK.SDKModel.SDKModel<void> implemen
 }
 
 export class NodeConnection implements ProtocolClient.InspectorBackend.Connection {
-  private readonly targetAgent: ProtocolProxyApi.TargetApi;
-  private readonly sessionId: Protocol.Target.SessionID;
+  readonly #targetAgent: ProtocolProxyApi.TargetApi;
+  readonly #sessionId: Protocol.Target.SessionID;
   onMessage: ((arg0: (Object|string)) => void)|null;
-  private onDisconnect: ((arg0: string) => void)|null;
+  #onDisconnect: ((arg0: string) => void)|null;
   constructor(targetAgent: ProtocolProxyApi.TargetApi, sessionId: Protocol.Target.SessionID) {
-    this.targetAgent = targetAgent;
-    this.sessionId = sessionId;
+    this.#targetAgent = targetAgent;
+    this.#sessionId = sessionId;
     this.onMessage = null;
-    this.onDisconnect = null;
+    this.#onDisconnect = null;
   }
 
   setOnMessage(onMessage: (arg0: (Object|string)) => void): void {
@@ -149,20 +149,20 @@ export class NodeConnection implements ProtocolClient.InspectorBackend.Connectio
   }
 
   setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.onDisconnect = onDisconnect;
+    this.#onDisconnect = onDisconnect;
   }
 
   sendRawMessage(message: string): void {
-    this.targetAgent.invoke_sendMessageToTarget({message, sessionId: this.sessionId});
+    this.#targetAgent.invoke_sendMessageToTarget({message, sessionId: this.#sessionId});
   }
 
   async disconnect(): Promise<void> {
-    if (this.onDisconnect) {
-      this.onDisconnect.call(null, 'force disconnect');
+    if (this.#onDisconnect) {
+      this.#onDisconnect.call(null, 'force disconnect');
     }
-    this.onDisconnect = null;
+    this.#onDisconnect = null;
     this.onMessage = null;
-    await this.targetAgent.invoke_detachFromTarget({sessionId: this.sessionId});
+    await this.#targetAgent.invoke_detachFromTarget({sessionId: this.#sessionId});
   }
 }
 

package/front_end/generated/InspectorBackendCommands.js

@@ -279,6 +279,9 @@ export function registerCommands(inspectorBackend) {
   });
   inspectorBackend.registerEnum(
       'Audits.GenericIssueErrorType', {CrossOriginPortalPostMessageError: 'CrossOriginPortalPostMessageError'});
+  inspectorBackend.registerEnum(
+      'Audits.ClientHintIssueReason',
+      {MetaTagAllowListInvalidOrigin: 'MetaTagAllowListInvalidOrigin', MetaTagModifiedHTML: 'MetaTagModifiedHTML'});
   inspectorBackend.registerEnum('Audits.InspectorIssueCode', {
     SameSiteCookieIssue: 'SameSiteCookieIssue',
     MixedContentIssue: 'MixedContentIssue',
@@ -294,7 +297,8 @@ export function registerCommands(inspectorBackend) {
     NavigatorUserAgentIssue: 'NavigatorUserAgentIssue',
     WasmCrossOriginModuleSharingIssue: 'WasmCrossOriginModuleSharingIssue',
     GenericIssue: 'GenericIssue',
-    DeprecationIssue: 'DeprecationIssue'
+    DeprecationIssue: 'DeprecationIssue',
+    ClientHintIssue: 'ClientHintIssue'
   });
   inspectorBackend.registerEvent('Audits.issueAdded', ['issue']);
   inspectorBackend.registerEnum('Audits.GetEncodedResponseRequestEncoding', {Webp: 'webp', Jpeg: 'jpeg', Png: 'png'});

package/front_end/generated/protocol.d.ts

@@ -1049,6 +1049,20 @@ declare namespace Protocol {
       message?: string;
     }
 
+    export const enum ClientHintIssueReason {
+      MetaTagAllowListInvalidOrigin = 'MetaTagAllowListInvalidOrigin',
+      MetaTagModifiedHTML = 'MetaTagModifiedHTML',
+    }
+
+    /**
+     * This issue tracks client hints related issues. It's used to deprecate old
+     * features, encourage the use of new ones, and provide general guidance.
+     */
+    export interface ClientHintIssueDetails {
+      sourceCodeLocation: SourceCodeLocation;
+      clientHintIssueReason: ClientHintIssueReason;
+    }
+
     /**
      * A unique identifier for the type of issue. Each type may use one of the
      * optional fields in InspectorIssueDetails to convey more specific
@@ -1070,6 +1084,7 @@ declare namespace Protocol {
       WasmCrossOriginModuleSharingIssue = 'WasmCrossOriginModuleSharingIssue',
       GenericIssue = 'GenericIssue',
       DeprecationIssue = 'DeprecationIssue',
+      ClientHintIssue = 'ClientHintIssue',
     }
 
     /**
@@ -1093,6 +1108,7 @@ declare namespace Protocol {
       wasmCrossOriginModuleSharingIssue?: WasmCrossOriginModuleSharingIssueDetails;
       genericIssueDetails?: GenericIssueDetails;
       deprecationIssueDetails?: DeprecationIssueDetails;
+      clientHintIssueDetails?: ClientHintIssueDetails;
     }
 
     /**

package/front_end/models/issues_manager/ContentSecurityPolicyIssue.ts

@@ -36,7 +36,7 @@ const str_ = i18n.i18n.registerUIStrings('models/issues_manager/ContentSecurityP
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
 
 export class ContentSecurityPolicyIssue extends Issue {
-  private issueDetails: Protocol.Audits.ContentSecurityPolicyIssueDetails;
+  #issueDetails: Protocol.Audits.ContentSecurityPolicyIssueDetails;
 
   constructor(
       issueDetails: Protocol.Audits.ContentSecurityPolicyIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel,
@@ -46,7 +46,7 @@ export class ContentSecurityPolicyIssue extends Issue {
       issueDetails.contentSecurityPolicyViolationType,
     ].join('::');
     super(issueCode, issuesModel, issueId);
-    this.issueDetails = issueDetails;
+    this.#issueDetails = issueDetails;
   }
 
   getCategory(): IssueCategory {
@@ -54,7 +54,7 @@ export class ContentSecurityPolicyIssue extends Issue {
   }
 
   primaryKey(): string {
-    return JSON.stringify(this.issueDetails, [
+    return JSON.stringify(this.#issueDetails, [
       'blockedURL',
       'contentSecurityPolicyViolationType',
       'violatedDirective',
@@ -68,7 +68,7 @@ export class ContentSecurityPolicyIssue extends Issue {
   }
 
   getDescription(): MarkdownIssueDescription|null {
-    const description = issueDescriptions.get(this.issueDetails.contentSecurityPolicyViolationType);
+    const description = issueDescriptions.get(this.#issueDetails.contentSecurityPolicyViolationType);
     if (!description) {
       return null;
     }
@@ -76,11 +76,11 @@ export class ContentSecurityPolicyIssue extends Issue {
   }
 
   details(): Protocol.Audits.ContentSecurityPolicyIssueDetails {
-    return this.issueDetails;
+    return this.#issueDetails;
   }
 
   getKind(): IssueKind {
-    if (this.issueDetails.isReportOnly) {
+    if (this.#issueDetails.isReportOnly) {
       return IssueKind.Improvement;
     }
     return IssueKind.PageError;

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 {