chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/OverlayPersistentHighlighter.ts

@@ -8,56 +8,55 @@ import * as Common from '../common/common.js';
 import {OverlayColorGenerator} from './OverlayColorGenerator.js';
 
 export class OverlayPersistentHighlighter {
-  private readonly model: OverlayModel;
-  private readonly gridHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.GridHighlightConfig>;
-  private readonly scrollSnapHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.ScrollSnapContainerHighlightConfig>;
-  private readonly flexHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.FlexContainerHighlightConfig>;
-  private readonly containerQueryHighlights:
-      Map<Protocol.DOM.NodeId, Protocol.Overlay.ContainerQueryContainerHighlightConfig>;
-  private readonly isolatedElementHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.IsolationModeHighlightConfig>;
-  private readonly colors: Map<Protocol.DOM.NodeId, Common.Color.Color>;
-  private gridColorGenerator: OverlayColorGenerator;
-  private flexColorGenerator: OverlayColorGenerator;
-  private flexEnabled: boolean;
+  readonly #model: OverlayModel;
+  readonly #gridHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.GridHighlightConfig>;
+  readonly #scrollSnapHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.ScrollSnapContainerHighlightConfig>;
+  readonly #flexHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.FlexContainerHighlightConfig>;
+  readonly #containerQueryHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.ContainerQueryContainerHighlightConfig>;
+  readonly #isolatedElementHighlights: Map<Protocol.DOM.NodeId, Protocol.Overlay.IsolationModeHighlightConfig>;
+  readonly #colors: Map<Protocol.DOM.NodeId, Common.Color.Color>;
+  #gridColorGenerator: OverlayColorGenerator;
+  #flexColorGenerator: OverlayColorGenerator;
+  #flexEnabled: boolean;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly showGridLineLabelsSetting: Common.Settings.Setting<any>;
+  readonly #showGridLineLabelsSetting: Common.Settings.Setting<any>;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly extendGridLinesSetting: Common.Settings.Setting<any>;
+  readonly #extendGridLinesSetting: Common.Settings.Setting<any>;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly showGridAreasSetting: Common.Settings.Setting<any>;
+  readonly #showGridAreasSetting: Common.Settings.Setting<any>;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly showGridTrackSizesSetting: Common.Settings.Setting<any>;
+  readonly #showGridTrackSizesSetting: Common.Settings.Setting<any>;
   constructor(model: OverlayModel, flexEnabled: boolean = true) {
-    this.model = model;
+    this.#model = model;
 
-    this.gridHighlights = new Map();
+    this.#gridHighlights = new Map();
 
-    this.scrollSnapHighlights = new Map();
+    this.#scrollSnapHighlights = new Map();
 
-    this.flexHighlights = new Map();
+    this.#flexHighlights = new Map();
 
-    this.containerQueryHighlights = new Map();
+    this.#containerQueryHighlights = new Map();
 
-    this.isolatedElementHighlights = new Map();
+    this.#isolatedElementHighlights = new Map();
 
-    this.colors = new Map();
+    this.#colors = new Map();
 
-    this.gridColorGenerator = new OverlayColorGenerator();
-    this.flexColorGenerator = new OverlayColorGenerator();
-    this.flexEnabled = flexEnabled;
+    this.#gridColorGenerator = new OverlayColorGenerator();
+    this.#flexColorGenerator = new OverlayColorGenerator();
+    this.#flexEnabled = flexEnabled;
 
-    this.showGridLineLabelsSetting = Common.Settings.Settings.instance().moduleSetting('showGridLineLabels');
-    this.showGridLineLabelsSetting.addChangeListener(this.onSettingChange, this);
-    this.extendGridLinesSetting = Common.Settings.Settings.instance().moduleSetting('extendGridLines');
-    this.extendGridLinesSetting.addChangeListener(this.onSettingChange, this);
-    this.showGridAreasSetting = Common.Settings.Settings.instance().moduleSetting('showGridAreas');
-    this.showGridAreasSetting.addChangeListener(this.onSettingChange, this);
-    this.showGridTrackSizesSetting = Common.Settings.Settings.instance().moduleSetting('showGridTrackSizes');
-    this.showGridTrackSizesSetting.addChangeListener(this.onSettingChange, this);
+    this.#showGridLineLabelsSetting = Common.Settings.Settings.instance().moduleSetting('showGridLineLabels');
+    this.#showGridLineLabelsSetting.addChangeListener(this.onSettingChange, this);
+    this.#extendGridLinesSetting = Common.Settings.Settings.instance().moduleSetting('extendGridLines');
+    this.#extendGridLinesSetting.addChangeListener(this.onSettingChange, this);
+    this.#showGridAreasSetting = Common.Settings.Settings.instance().moduleSetting('showGridAreas');
+    this.#showGridAreasSetting.addChangeListener(this.onSettingChange, this);
+    this.#showGridTrackSizesSetting = Common.Settings.Settings.instance().moduleSetting('showGridTrackSizes');
+    this.#showGridTrackSizesSetting.addChangeListener(this.onSettingChange, this);
   }
 
   private onSettingChange(): void {
@@ -70,10 +69,10 @@ export class OverlayPersistentHighlighter {
     const gapBackground = mainColor.setAlpha(0.3);
     const gapHatch = mainColor.setAlpha(0.8);
 
-    const showGridExtensionLines = (this.extendGridLinesSetting.get() as boolean);
-    const showPositiveLineNumbers = this.showGridLineLabelsSetting.get() === 'lineNumbers';
+    const showGridExtensionLines = (this.#extendGridLinesSetting.get() as boolean);
+    const showPositiveLineNumbers = this.#showGridLineLabelsSetting.get() === 'lineNumbers';
     const showNegativeLineNumbers = showPositiveLineNumbers;
-    const showLineNames = this.showGridLineLabelsSetting.get() === 'lineNames';
+    const showLineNames = this.#showGridLineLabelsSetting.get() === 'lineNames';
     return {
       rowGapColor: gapBackground.toProtocolRGBA(),
       rowHatchColor: gapHatch.toProtocolRGBA(),
@@ -89,8 +88,8 @@ export class OverlayPersistentHighlighter {
       showPositiveLineNumbers,
       showNegativeLineNumbers,
       showLineNames,
-      showAreaNames: (this.showGridAreasSetting.get() as boolean),
-      showTrackSizes: (this.showGridTrackSizesSetting.get() as boolean),
+      showAreaNames: (this.#showGridAreasSetting.get() as boolean),
+      showTrackSizes: (this.#showGridTrackSizesSetting.get() as boolean),
       areaBorderColor: mainColor.toProtocolRGBA(),
       gridBackgroundColor: background.toProtocolRGBA(),
     };
@@ -122,95 +121,95 @@ export class OverlayPersistentHighlighter {
   }
 
   highlightGridInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    this.gridHighlights.set(nodeId, this.buildGridHighlightConfig(nodeId));
+    this.#gridHighlights.set(nodeId, this.buildGridHighlightConfig(nodeId));
     this.updateHighlightsInOverlay();
   }
 
   isGridHighlighted(nodeId: Protocol.DOM.NodeId): boolean {
-    return this.gridHighlights.has(nodeId);
+    return this.#gridHighlights.has(nodeId);
   }
 
   colorOfGrid(nodeId: Protocol.DOM.NodeId): Common.Color.Color {
-    let color = this.colors.get(nodeId);
+    let color = this.#colors.get(nodeId);
     if (!color) {
-      color = this.gridColorGenerator.next();
-      this.colors.set(nodeId, color);
+      color = this.#gridColorGenerator.next();
+      this.#colors.set(nodeId, color);
     }
 
     return color;
   }
 
   setColorOfGrid(nodeId: Protocol.DOM.NodeId, color: Common.Color.Color): void {
-    this.colors.set(nodeId, color);
+    this.#colors.set(nodeId, color);
   }
 
   hideGridInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    if (this.gridHighlights.has(nodeId)) {
-      this.gridHighlights.delete(nodeId);
+    if (this.#gridHighlights.has(nodeId)) {
+      this.#gridHighlights.delete(nodeId);
       this.updateHighlightsInOverlay();
     }
   }
 
   highlightScrollSnapInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    this.scrollSnapHighlights.set(nodeId, this.buildScrollSnapContainerHighlightConfig(nodeId));
+    this.#scrollSnapHighlights.set(nodeId, this.buildScrollSnapContainerHighlightConfig(nodeId));
     this.updateHighlightsInOverlay();
   }
 
   isScrollSnapHighlighted(nodeId: Protocol.DOM.NodeId): boolean {
-    return this.scrollSnapHighlights.has(nodeId);
+    return this.#scrollSnapHighlights.has(nodeId);
   }
 
   hideScrollSnapInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    if (this.scrollSnapHighlights.has(nodeId)) {
-      this.scrollSnapHighlights.delete(nodeId);
+    if (this.#scrollSnapHighlights.has(nodeId)) {
+      this.#scrollSnapHighlights.delete(nodeId);
       this.updateHighlightsInOverlay();
     }
   }
 
   highlightFlexInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    this.flexHighlights.set(nodeId, this.buildFlexContainerHighlightConfig(nodeId));
+    this.#flexHighlights.set(nodeId, this.buildFlexContainerHighlightConfig(nodeId));
     this.updateHighlightsInOverlay();
   }
 
   isFlexHighlighted(nodeId: Protocol.DOM.NodeId): boolean {
-    return this.flexHighlights.has(nodeId);
+    return this.#flexHighlights.has(nodeId);
   }
 
   colorOfFlex(nodeId: Protocol.DOM.NodeId): Common.Color.Color {
-    let color = this.colors.get(nodeId);
+    let color = this.#colors.get(nodeId);
     if (!color) {
-      color = this.flexColorGenerator.next();
-      this.colors.set(nodeId, color);
+      color = this.#flexColorGenerator.next();
+      this.#colors.set(nodeId, color);
     }
 
     return color;
   }
 
   setColorOfFlex(nodeId: Protocol.DOM.NodeId, color: Common.Color.Color): void {
-    this.colors.set(nodeId, color);
+    this.#colors.set(nodeId, color);
   }
 
   hideFlexInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    if (this.flexHighlights.has(nodeId)) {
-      this.flexHighlights.delete(nodeId);
+    if (this.#flexHighlights.has(nodeId)) {
+      this.#flexHighlights.delete(nodeId);
       this.updateHighlightsInOverlay();
     }
   }
 
   highlightContainerQueryInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    this.containerQueryHighlights.set(nodeId, this.buildContainerQueryContainerHighlightConfig());
+    this.#containerQueryHighlights.set(nodeId, this.buildContainerQueryContainerHighlightConfig());
     this.updateHighlightsInOverlay();
   }
 
   hideContainerQueryInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    if (this.containerQueryHighlights.has(nodeId)) {
-      this.containerQueryHighlights.delete(nodeId);
+    if (this.#containerQueryHighlights.has(nodeId)) {
+      this.#containerQueryHighlights.delete(nodeId);
       this.updateHighlightsInOverlay();
     }
   }
 
   isContainerQueryHighlighted(nodeId: Protocol.DOM.NodeId): boolean {
-    return this.containerQueryHighlights.has(nodeId);
+    return this.#containerQueryHighlights.has(nodeId);
   }
 
   private buildContainerQueryContainerHighlightConfig(): Protocol.Overlay.ContainerQueryContainerHighlightConfig {
@@ -227,19 +226,19 @@ export class OverlayPersistentHighlighter {
   }
 
   highlightIsolatedElementInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    this.isolatedElementHighlights.set(nodeId, this.buildIsolationModeHighlightConfig());
+    this.#isolatedElementHighlights.set(nodeId, this.buildIsolationModeHighlightConfig());
     this.updateHighlightsInOverlay();
   }
 
   hideIsolatedElementInOverlay(nodeId: Protocol.DOM.NodeId): void {
-    if (this.isolatedElementHighlights.has(nodeId)) {
-      this.isolatedElementHighlights.delete(nodeId);
+    if (this.#isolatedElementHighlights.has(nodeId)) {
+      this.#isolatedElementHighlights.delete(nodeId);
       this.updateHighlightsInOverlay();
     }
   }
 
   isIsolatedElementHighlighted(nodeId: Protocol.DOM.NodeId): boolean {
-    return this.isolatedElementHighlights.has(nodeId);
+    return this.#isolatedElementHighlights.has(nodeId);
   }
 
   private buildIsolationModeHighlightConfig(): Protocol.Overlay.IsolationModeHighlightConfig {
@@ -251,20 +250,20 @@ export class OverlayPersistentHighlighter {
   }
 
   hideAllInOverlay(): void {
-    this.flexHighlights.clear();
-    this.gridHighlights.clear();
-    this.scrollSnapHighlights.clear();
-    this.containerQueryHighlights.clear();
-    this.isolatedElementHighlights.clear();
+    this.#flexHighlights.clear();
+    this.#gridHighlights.clear();
+    this.#scrollSnapHighlights.clear();
+    this.#containerQueryHighlights.clear();
+    this.#isolatedElementHighlights.clear();
     this.updateHighlightsInOverlay();
   }
 
   refreshHighlights(): void {
-    const gridsNeedUpdate = this.updateHighlightsForDeletedNodes(this.gridHighlights);
-    const flexboxesNeedUpdate = this.updateHighlightsForDeletedNodes(this.flexHighlights);
-    const scrollSnapsNeedUpdate = this.updateHighlightsForDeletedNodes(this.scrollSnapHighlights);
-    const containerQueriesNeedUpdate = this.updateHighlightsForDeletedNodes(this.containerQueryHighlights);
-    const isolatedElementsNeedUpdate = this.updateHighlightsForDeletedNodes(this.isolatedElementHighlights);
+    const gridsNeedUpdate = this.updateHighlightsForDeletedNodes(this.#gridHighlights);
+    const flexboxesNeedUpdate = this.updateHighlightsForDeletedNodes(this.#flexHighlights);
+    const scrollSnapsNeedUpdate = this.updateHighlightsForDeletedNodes(this.#scrollSnapHighlights);
+    const containerQueriesNeedUpdate = this.updateHighlightsForDeletedNodes(this.#containerQueryHighlights);
+    const isolatedElementsNeedUpdate = this.updateHighlightsForDeletedNodes(this.#isolatedElementHighlights);
     if (flexboxesNeedUpdate || gridsNeedUpdate || scrollSnapsNeedUpdate || containerQueriesNeedUpdate ||
         isolatedElementsNeedUpdate) {
       this.updateHighlightsInOverlay();
@@ -274,7 +273,7 @@ export class OverlayPersistentHighlighter {
   private updateHighlightsForDeletedNodes(highlights: Map<Protocol.DOM.NodeId, unknown>): boolean {
     let needsUpdate = false;
     for (const nodeId of highlights.keys()) {
-      if (this.model.getDOMModel().nodeForId(nodeId) === null) {
+      if (this.#model.getDOMModel().nodeForId(nodeId) === null) {
         highlights.delete(nodeId);
         needsUpdate = true;
       }
@@ -283,28 +282,28 @@ export class OverlayPersistentHighlighter {
   }
 
   resetOverlay(): void {
-    for (const nodeId of this.gridHighlights.keys()) {
-      this.gridHighlights.set(nodeId, this.buildGridHighlightConfig(nodeId));
+    for (const nodeId of this.#gridHighlights.keys()) {
+      this.#gridHighlights.set(nodeId, this.buildGridHighlightConfig(nodeId));
     }
-    for (const nodeId of this.flexHighlights.keys()) {
-      this.flexHighlights.set(nodeId, this.buildFlexContainerHighlightConfig(nodeId));
+    for (const nodeId of this.#flexHighlights.keys()) {
+      this.#flexHighlights.set(nodeId, this.buildFlexContainerHighlightConfig(nodeId));
     }
-    for (const nodeId of this.scrollSnapHighlights.keys()) {
-      this.scrollSnapHighlights.set(nodeId, this.buildScrollSnapContainerHighlightConfig(nodeId));
+    for (const nodeId of this.#scrollSnapHighlights.keys()) {
+      this.#scrollSnapHighlights.set(nodeId, this.buildScrollSnapContainerHighlightConfig(nodeId));
     }
-    for (const nodeId of this.containerQueryHighlights.keys()) {
-      this.containerQueryHighlights.set(nodeId, this.buildContainerQueryContainerHighlightConfig());
+    for (const nodeId of this.#containerQueryHighlights.keys()) {
+      this.#containerQueryHighlights.set(nodeId, this.buildContainerQueryContainerHighlightConfig());
     }
-    for (const nodeId of this.isolatedElementHighlights.keys()) {
-      this.isolatedElementHighlights.set(nodeId, this.buildIsolationModeHighlightConfig());
+    for (const nodeId of this.#isolatedElementHighlights.keys()) {
+      this.#isolatedElementHighlights.set(nodeId, this.buildIsolationModeHighlightConfig());
     }
     this.updateHighlightsInOverlay();
   }
 
   private updateHighlightsInOverlay(): void {
-    const hasNodesToHighlight = this.gridHighlights.size > 0 || this.flexHighlights.size > 0 ||
-        this.containerQueryHighlights.size > 0 || this.isolatedElementHighlights.size > 0;
-    this.model.setShowViewportSizeOnResize(!hasNodesToHighlight);
+    const hasNodesToHighlight = this.#gridHighlights.size > 0 || this.#flexHighlights.size > 0 ||
+        this.#containerQueryHighlights.size > 0 || this.#isolatedElementHighlights.size > 0;
+    this.#model.setShowViewportSizeOnResize(!hasNodesToHighlight);
     this.updateGridHighlightsInOverlay();
     this.updateFlexHighlightsInOverlay();
     this.updateScrollSnapHighlightsInOverlay();
@@ -313,48 +312,48 @@ export class OverlayPersistentHighlighter {
   }
 
   private updateGridHighlightsInOverlay(): void {
-    const overlayModel = this.model;
+    const overlayModel = this.#model;
     const gridNodeHighlightConfigs = [];
-    for (const [nodeId, gridHighlightConfig] of this.gridHighlights.entries()) {
+    for (const [nodeId, gridHighlightConfig] of this.#gridHighlights.entries()) {
       gridNodeHighlightConfigs.push({nodeId, gridHighlightConfig});
     }
     overlayModel.target().overlayAgent().invoke_setShowGridOverlays({gridNodeHighlightConfigs});
   }
 
   private updateFlexHighlightsInOverlay(): void {
-    if (!this.flexEnabled) {
+    if (!this.#flexEnabled) {
       return;
     }
-    const overlayModel = this.model;
+    const overlayModel = this.#model;
     const flexNodeHighlightConfigs = [];
-    for (const [nodeId, flexContainerHighlightConfig] of this.flexHighlights.entries()) {
+    for (const [nodeId, flexContainerHighlightConfig] of this.#flexHighlights.entries()) {
       flexNodeHighlightConfigs.push({nodeId, flexContainerHighlightConfig});
     }
     overlayModel.target().overlayAgent().invoke_setShowFlexOverlays({flexNodeHighlightConfigs});
   }
 
   private updateScrollSnapHighlightsInOverlay(): void {
-    const overlayModel = this.model;
+    const overlayModel = this.#model;
     const scrollSnapHighlightConfigs = [];
-    for (const [nodeId, scrollSnapContainerHighlightConfig] of this.scrollSnapHighlights.entries()) {
+    for (const [nodeId, scrollSnapContainerHighlightConfig] of this.#scrollSnapHighlights.entries()) {
       scrollSnapHighlightConfigs.push({nodeId, scrollSnapContainerHighlightConfig});
     }
     overlayModel.target().overlayAgent().invoke_setShowScrollSnapOverlays({scrollSnapHighlightConfigs});
   }
 
   updateContainerQueryHighlightsInOverlay(): void {
-    const overlayModel = this.model;
+    const overlayModel = this.#model;
     const containerQueryHighlightConfigs = [];
-    for (const [nodeId, containerQueryContainerHighlightConfig] of this.containerQueryHighlights.entries()) {
+    for (const [nodeId, containerQueryContainerHighlightConfig] of this.#containerQueryHighlights.entries()) {
       containerQueryHighlightConfigs.push({nodeId, containerQueryContainerHighlightConfig});
     }
     overlayModel.target().overlayAgent().invoke_setShowContainerQueryOverlays({containerQueryHighlightConfigs});
   }
 
   updateIsolatedElementHighlightsInOverlay(): void {
-    const overlayModel = this.model;
+    const overlayModel = this.#model;
     const isolatedElementHighlightConfigs = [];
-    for (const [nodeId, isolationModeHighlightConfig] of this.isolatedElementHighlights.entries()) {
+    for (const [nodeId, isolationModeHighlightConfig] of this.#isolatedElementHighlights.entries()) {
       isolatedElementHighlightConfigs.push({nodeId, isolationModeHighlightConfig});
     }
     overlayModel.target().overlayAgent().invoke_setShowIsolatedElements({isolatedElementHighlightConfigs});

package/front_end/core/sdk/PageResourceLoader.ts

@@ -60,16 +60,16 @@ interface LoadQueueEntry {
  * resources were loaded, and whether there was a load error.
  */
 export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
-  private currentlyLoading: number;
-  private readonly maxConcurrentLoads: number;
-  private readonly pageResources: Map<string, PageResource>;
-  private queuedLoads: LoadQueueEntry[];
-  private readonly loadOverride: ((arg0: string) => Promise<{
-                                    success: boolean,
-                                    content: string,
-                                    errorDescription: Host.ResourceLoader.LoadErrorDescription,
-                                  }>)|null;
-  private readonly loadTimeout: number;
+  #currentlyLoading: number;
+  readonly #maxConcurrentLoads: number;
+  readonly #pageResources: Map<string, PageResource>;
+  #queuedLoads: LoadQueueEntry[];
+  readonly #loadOverride: ((arg0: string) => Promise<{
+                             success: boolean,
+                             content: string,
+                             errorDescription: Host.ResourceLoader.LoadErrorDescription,
+                           }>)|null;
+  readonly #loadTimeout: number;
   constructor(
       loadOverride: ((arg0: string) => Promise<{
                        success: boolean,
@@ -78,14 +78,14 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
                      }>)|null,
       maxConcurrentLoads: number, loadTimeout: number) {
     super();
-    this.currentlyLoading = 0;
-    this.maxConcurrentLoads = maxConcurrentLoads;
-    this.pageResources = new Map();
-    this.queuedLoads = [];
+    this.#currentlyLoading = 0;
+    this.#maxConcurrentLoads = maxConcurrentLoads;
+    this.#pageResources = new Map();
+    this.#queuedLoads = [];
     TargetManager.instance().addModelListener(
         ResourceTreeModel, ResourceTreeModelEvents.MainFrameNavigated, this.onMainFrameNavigated, this);
-    this.loadOverride = loadOverride;
-    this.loadTimeout = loadTimeout;
+    this.#loadOverride = loadOverride;
+    this.#loadTimeout = loadTimeout;
   }
 
   static instance({forceNew, loadOverride, maxConcurrentLoads, loadTimeout}: {
@@ -115,16 +115,16 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     if (!mainFrame.isTopFrame()) {
       return;
     }
-    for (const {reject} of this.queuedLoads) {
+    for (const {reject} of this.#queuedLoads) {
       reject(new Error(i18nString(UIStrings.loadCanceledDueToReloadOf)));
     }
-    this.queuedLoads = [];
-    this.pageResources.clear();
+    this.#queuedLoads = [];
+    this.#pageResources.clear();
     this.dispatchEventToListeners(Events.Update);
   }
 
   getResourcesLoaded(): Map<string, PageResource> {
-    return this.pageResources;
+    return this.#pageResources;
   }
 
   /**
@@ -137,25 +137,25 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     queued: number,
     resources: number,
   } {
-    return {loading: this.currentlyLoading, queued: this.queuedLoads.length, resources: this.pageResources.size};
+    return {loading: this.#currentlyLoading, queued: this.#queuedLoads.length, resources: this.#pageResources.size};
   }
 
   private async acquireLoadSlot(): Promise<void> {
-    this.currentlyLoading++;
-    if (this.currentlyLoading > this.maxConcurrentLoads) {
+    this.#currentlyLoading++;
+    if (this.#currentlyLoading > this.#maxConcurrentLoads) {
       const entry: LoadQueueEntry = {resolve: (): void => {}, reject: (): void => {}};
       const waitForCapacity = new Promise<void>((resolve, reject) => {
         entry.resolve = resolve;
         entry.reject = reject;
       });
-      this.queuedLoads.push(entry);
+      this.#queuedLoads.push(entry);
       await waitForCapacity;
     }
   }
 
   private releaseLoadSlot(): void {
-    this.currentlyLoading--;
-    const entry = this.queuedLoads.shift();
+    this.#currentlyLoading--;
+    const entry = this.#queuedLoads.shift();
     if (entry) {
       entry.resolve();
     }
@@ -182,12 +182,12 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
   }> {
     const key = PageResourceLoader.makeKey(url, initiator);
     const pageResource: PageResource = {success: null, size: null, errorMessage: undefined, url, initiator};
-    this.pageResources.set(key, pageResource);
+    this.#pageResources.set(key, pageResource);
     this.dispatchEventToListeners(Events.Update);
     try {
       await this.acquireLoadSlot();
       const resultPromise = this.dispatchLoad(url, initiator);
-      const result = await PageResourceLoader.withTimeout(resultPromise, this.loadTimeout);
+      const result = await PageResourceLoader.withTimeout(resultPromise, this.#loadTimeout);
       pageResource.errorMessage = result.errorDescription.message;
       pageResource.success = result.success;
       if (result.success) {
@@ -215,8 +215,8 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     errorDescription: Host.ResourceLoader.LoadErrorDescription,
   }> {
     let failureReason: string|null = null;
-    if (this.loadOverride) {
-      return this.loadOverride(url);
+    if (this.#loadOverride) {
+      return this.#loadOverride(url);
     }
     const parsedURL = new Common.ParsedURL.ParsedURL(url);
     const eligibleForLoadFromTarget = getLoadThroughTargetSetting().get() && parsedURL && parsedURL.isHttpOrHttps();

package/front_end/core/sdk/PaintProfiler.ts

@@ -60,43 +60,43 @@ export class PaintProfilerModel extends SDKModel<void> {
 }
 
 export class PaintProfilerSnapshot {
-  private readonly paintProfilerModel: PaintProfilerModel;
-  private readonly id: Protocol.LayerTree.SnapshotId;
-  private refCount: number;
+  readonly #paintProfilerModel: PaintProfilerModel;
+  readonly #id: Protocol.LayerTree.SnapshotId;
+  #refCount: number;
 
   constructor(paintProfilerModel: PaintProfilerModel, snapshotId: Protocol.LayerTree.SnapshotId) {
-    this.paintProfilerModel = paintProfilerModel;
-    this.id = snapshotId;
-    this.refCount = 1;
+    this.#paintProfilerModel = paintProfilerModel;
+    this.#id = snapshotId;
+    this.#refCount = 1;
   }
 
   release(): void {
-    console.assert(this.refCount > 0, 'release is already called on the object');
-    if (!--this.refCount) {
-      this.paintProfilerModel.layerTreeAgent.invoke_releaseSnapshot({snapshotId: this.id});
+    console.assert(this.#refCount > 0, 'release is already called on the object');
+    if (!--this.#refCount) {
+      this.#paintProfilerModel.layerTreeAgent.invoke_releaseSnapshot({snapshotId: this.#id});
     }
   }
 
   addReference(): void {
-    ++this.refCount;
-    console.assert(this.refCount > 0, 'Referencing a dead object');
+    ++this.#refCount;
+    console.assert(this.#refCount > 0, 'Referencing a dead object');
   }
 
   async replay(scale?: number, fromStep?: number, toStep?: number): Promise<string|null> {
-    const response = await this.paintProfilerModel.layerTreeAgent.invoke_replaySnapshot(
-        {snapshotId: this.id, fromStep, toStep, scale: scale || 1.0});
+    const response = await this.#paintProfilerModel.layerTreeAgent.invoke_replaySnapshot(
+        {snapshotId: this.#id, fromStep, toStep, scale: scale || 1.0});
     return response.dataURL;
   }
 
   async profile(clipRect: Protocol.DOM.Rect|null): Promise<Protocol.LayerTree.PaintProfile[]> {
-    const response = await this.paintProfilerModel.layerTreeAgent.invoke_profileSnapshot(
-        {snapshotId: this.id, minRepeatCount: 5, minDuration: 1, clipRect: clipRect || undefined});
+    const response = await this.#paintProfilerModel.layerTreeAgent.invoke_profileSnapshot(
+        {snapshotId: this.#id, minRepeatCount: 5, minDuration: 1, clipRect: clipRect || undefined});
 
     return response.timings;
   }
 
   async commandLog(): Promise<PaintProfilerLogItem[]|null> {
-    const response = await this.paintProfilerModel.layerTreeAgent.invoke_snapshotCommandLog({snapshotId: this.id});
+    const response = await this.#paintProfilerModel.layerTreeAgent.invoke_snapshotCommandLog({snapshotId: this.#id});
 
     return response.commandLog ? response.commandLog.map((entry, index) => new PaintProfilerLogItem(entry, index)) :
                                  null;

package/front_end/core/sdk/PerformanceMetricsModel.ts

@@ -10,18 +10,18 @@ import {Capability} from './Target.js';
 import {SDKModel} from './SDKModel.js';
 
 export class PerformanceMetricsModel extends SDKModel<void> {
-  private readonly agent: ProtocolProxyApi.PerformanceApi;
-  private readonly metricModes: Map<string, MetricMode>;
-  private readonly metricData: Map<string, {
+  readonly #agent: ProtocolProxyApi.PerformanceApi;
+  readonly #metricModes: Map<string, MetricMode>;
+  readonly #metricData: Map<string, {
     lastValue: (number | undefined),
     lastTimestamp: (number|undefined),
   }>;
 
   constructor(target: Target) {
     super(target);
-    this.agent = target.performanceAgent();
+    this.#agent = target.performanceAgent();
 
-    this.metricModes = new Map([
+    this.#metricModes = new Map([
       ['TaskDuration', MetricMode.CumulativeTime],
       ['ScriptDuration', MetricMode.CumulativeTime],
       ['LayoutDuration', MetricMode.CumulativeTime],
@@ -30,32 +30,32 @@ export class PerformanceMetricsModel extends SDKModel<void> {
       ['RecalcStyleCount', MetricMode.CumulativeCount],
     ]);
 
-    this.metricData = new Map();
+    this.#metricData = new Map();
   }
 
   enable(): Promise<Object> {
-    return this.agent.invoke_enable({});
+    return this.#agent.invoke_enable({});
   }
 
   disable(): Promise<Object> {
-    return this.agent.invoke_disable();
+    return this.#agent.invoke_disable();
   }
 
   async requestMetrics(): Promise<{
     metrics: Map<string, number>,
     timestamp: number,
   }> {
-    const rawMetrics = await this.agent.invoke_getMetrics() || [];
+    const rawMetrics = await this.#agent.invoke_getMetrics() || [];
     const metrics = new Map<string, number>();
     const timestamp = performance.now();
     for (const metric of rawMetrics.metrics) {
-      let data = this.metricData.get(metric.name);
+      let data = this.#metricData.get(metric.name);
       if (!data) {
         data = {lastValue: undefined, lastTimestamp: undefined};
-        this.metricData.set(metric.name, data);
+        this.#metricData.set(metric.name, data);
       }
       let value;
-      switch (this.metricModes.get(metric.name)) {
+      switch (this.#metricModes.get(metric.name)) {
         case MetricMode.CumulativeTime:
           value = (data.lastTimestamp && data.lastValue) ?
               Platform.NumberUtilities.clamp(