chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/AccessibilityModel.ts

@@ -27,119 +27,119 @@ export interface CoreOrProtocolAxProperty {
 }
 
 export class AccessibilityNode {
-  private readonly accessibilityModelInternal: AccessibilityModel;
-  private readonly agent: ProtocolProxyApi.AccessibilityApi;
-  private readonly idInternal: Protocol.Accessibility.AXNodeId;
-  private readonly backendDOMNodeIdInternal: Protocol.DOM.BackendNodeId|null;
-  private readonly deferredDOMNodeInternal: DeferredDOMNode|null;
-  private readonly ignoredInternal: boolean;
-  private readonly ignoredReasonsInternal: Protocol.Accessibility.AXProperty[]|undefined;
-  private readonly roleInternal: Protocol.Accessibility.AXValue|null;
-  private readonly nameInternal: Protocol.Accessibility.AXValue|null;
-  private readonly descriptionInternal: Protocol.Accessibility.AXValue|null;
-  private readonly valueInternal: Protocol.Accessibility.AXValue|null;
-  private readonly propertiesInternal: Protocol.Accessibility.AXProperty[]|null;
-  private childIds: string[]|null;
-  private parentNodeInternal: AccessibilityNode|null;
+  readonly #accessibilityModelInternal: AccessibilityModel;
+  readonly #agent: ProtocolProxyApi.AccessibilityApi;
+  readonly #idInternal: Protocol.Accessibility.AXNodeId;
+  readonly #backendDOMNodeIdInternal: Protocol.DOM.BackendNodeId|null;
+  readonly #deferredDOMNodeInternal: DeferredDOMNode|null;
+  readonly #ignoredInternal: boolean;
+  readonly #ignoredReasonsInternal: Protocol.Accessibility.AXProperty[]|undefined;
+  readonly #roleInternal: Protocol.Accessibility.AXValue|null;
+  readonly #nameInternal: Protocol.Accessibility.AXValue|null;
+  readonly #descriptionInternal: Protocol.Accessibility.AXValue|null;
+  readonly #valueInternal: Protocol.Accessibility.AXValue|null;
+  readonly #propertiesInternal: Protocol.Accessibility.AXProperty[]|null;
+  #childIds: string[]|null;
+  #parentNodeInternal: AccessibilityNode|null;
 
   constructor(accessibilityModel: AccessibilityModel, payload: Protocol.Accessibility.AXNode) {
-    this.accessibilityModelInternal = accessibilityModel;
-    this.agent = accessibilityModel.getAgent();
+    this.#accessibilityModelInternal = accessibilityModel;
+    this.#agent = accessibilityModel.getAgent();
 
-    this.idInternal = payload.nodeId;
-    accessibilityModel.setAXNodeForAXId(this.idInternal, this);
+    this.#idInternal = payload.nodeId;
+    accessibilityModel.setAXNodeForAXId(this.#idInternal, this);
     if (payload.backendDOMNodeId) {
       accessibilityModel.setAXNodeForBackendDOMNodeId(payload.backendDOMNodeId, this);
-      this.backendDOMNodeIdInternal = payload.backendDOMNodeId;
-      this.deferredDOMNodeInternal = new DeferredDOMNode(accessibilityModel.target(), payload.backendDOMNodeId);
+      this.#backendDOMNodeIdInternal = payload.backendDOMNodeId;
+      this.#deferredDOMNodeInternal = new DeferredDOMNode(accessibilityModel.target(), payload.backendDOMNodeId);
     } else {
-      this.backendDOMNodeIdInternal = null;
-      this.deferredDOMNodeInternal = null;
+      this.#backendDOMNodeIdInternal = null;
+      this.#deferredDOMNodeInternal = null;
     }
-    this.ignoredInternal = payload.ignored;
-    if (this.ignoredInternal && 'ignoredReasons' in payload) {
-      this.ignoredReasonsInternal = payload.ignoredReasons;
+    this.#ignoredInternal = payload.ignored;
+    if (this.#ignoredInternal && 'ignoredReasons' in payload) {
+      this.#ignoredReasonsInternal = payload.ignoredReasons;
     }
 
-    this.roleInternal = payload.role || null;
-    this.nameInternal = payload.name || null;
-    this.descriptionInternal = payload.description || null;
-    this.valueInternal = payload.value || null;
-    this.propertiesInternal = payload.properties || null;
-    this.childIds = payload.childIds || null;
-    this.parentNodeInternal = null;
+    this.#roleInternal = payload.role || null;
+    this.#nameInternal = payload.name || null;
+    this.#descriptionInternal = payload.description || null;
+    this.#valueInternal = payload.value || null;
+    this.#propertiesInternal = payload.properties || null;
+    this.#childIds = payload.childIds || null;
+    this.#parentNodeInternal = null;
   }
 
   id(): Protocol.Accessibility.AXNodeId {
-    return this.idInternal;
+    return this.#idInternal;
   }
 
   accessibilityModel(): AccessibilityModel {
-    return this.accessibilityModelInternal;
+    return this.#accessibilityModelInternal;
   }
 
   ignored(): boolean {
-    return this.ignoredInternal;
+    return this.#ignoredInternal;
   }
 
   ignoredReasons(): Protocol.Accessibility.AXProperty[]|null {
-    return this.ignoredReasonsInternal || null;
+    return this.#ignoredReasonsInternal || null;
   }
 
   role(): Protocol.Accessibility.AXValue|null {
-    return this.roleInternal || null;
+    return this.#roleInternal || null;
   }
 
   coreProperties(): CoreOrProtocolAxProperty[] {
     const properties: CoreOrProtocolAxProperty[] = [];
 
-    if (this.nameInternal) {
-      properties.push({name: CoreAxPropertyName.Name, value: this.nameInternal});
+    if (this.#nameInternal) {
+      properties.push({name: CoreAxPropertyName.Name, value: this.#nameInternal});
     }
-    if (this.descriptionInternal) {
-      properties.push({name: CoreAxPropertyName.Description, value: this.descriptionInternal});
+    if (this.#descriptionInternal) {
+      properties.push({name: CoreAxPropertyName.Description, value: this.#descriptionInternal});
     }
-    if (this.valueInternal) {
-      properties.push({name: CoreAxPropertyName.Value, value: this.valueInternal});
+    if (this.#valueInternal) {
+      properties.push({name: CoreAxPropertyName.Value, value: this.#valueInternal});
     }
 
     return properties;
   }
 
   name(): Protocol.Accessibility.AXValue|null {
-    return this.nameInternal || null;
+    return this.#nameInternal || null;
   }
 
   description(): Protocol.Accessibility.AXValue|null {
-    return this.descriptionInternal || null;
+    return this.#descriptionInternal || null;
   }
 
   value(): Protocol.Accessibility.AXValue|null {
-    return this.valueInternal || null;
+    return this.#valueInternal || null;
   }
 
   properties(): Protocol.Accessibility.AXProperty[]|null {
-    return this.propertiesInternal || null;
+    return this.#propertiesInternal || null;
   }
 
   parentNode(): AccessibilityNode|null {
-    return this.parentNodeInternal;
+    return this.#parentNodeInternal;
   }
 
   setParentNode(parentNode: AccessibilityNode|null): void {
-    this.parentNodeInternal = parentNode;
+    this.#parentNodeInternal = parentNode;
   }
 
   isDOMNode(): boolean {
-    return Boolean(this.backendDOMNodeIdInternal);
+    return Boolean(this.#backendDOMNodeIdInternal);
   }
 
   backendDOMNodeId(): Protocol.DOM.BackendNodeId|null {
-    return this.backendDOMNodeIdInternal;
+    return this.#backendDOMNodeIdInternal;
   }
 
   deferredDOMNode(): DeferredDOMNode|null {
-    return this.deferredDOMNodeInternal;
+    return this.#deferredDOMNodeInternal;
   }
 
   highlightDOMNode(): void {
@@ -152,13 +152,13 @@ export class AccessibilityNode {
   }
 
   children(): AccessibilityNode[] {
-    if (!this.childIds) {
+    if (!this.#childIds) {
       return [];
     }
 
     const children = [];
-    for (const childId of this.childIds) {
-      const child = this.accessibilityModelInternal.axNodeForId(childId);
+    for (const childId of this.#childIds) {
+      const child = this.#accessibilityModelInternal.axNodeForId(childId);
       if (child) {
         children.push(child);
       }
@@ -168,18 +168,18 @@ export class AccessibilityNode {
   }
 
   numChildren(): number {
-    if (!this.childIds) {
+    if (!this.#childIds) {
       return 0;
     }
-    return this.childIds.length;
+    return this.#childIds.length;
   }
 
   hasOnlyUnloadedChildren(): boolean {
-    if (!this.childIds || !this.childIds.length) {
+    if (!this.#childIds || !this.#childIds.length) {
       return false;
     }
 
-    return this.childIds.every(id => this.accessibilityModelInternal.axNodeForId(id) === null);
+    return this.#childIds.every(id => this.#accessibilityModelInternal.axNodeForId(id) === null);
   }
 
   // Only the root node gets a frameId, so nodes have to walk up the tree to find their frameId.
@@ -194,22 +194,22 @@ export class AccessibilityNode {
 
 export class AccessibilityModel extends SDKModel<void> {
   agent: ProtocolProxyApi.AccessibilityApi;
-  private axIdToAXNode: Map<string, AccessibilityNode>;
-  private readonly backendDOMNodeIdToAXNode: Map<Protocol.DOM.BackendNodeId, AccessibilityNode>;
-  private readonly backendDOMNodeIdToDOMNode: Map<Protocol.DOM.BackendNodeId, DOMNode|null>;
+  #axIdToAXNode: Map<string, AccessibilityNode>;
+  readonly #backendDOMNodeIdToAXNode: Map<Protocol.DOM.BackendNodeId, AccessibilityNode>;
+  readonly #backendDOMNodeIdToDOMNode: Map<Protocol.DOM.BackendNodeId, DOMNode|null>;
 
   constructor(target: Target) {
     super(target);
     this.agent = target.accessibilityAgent();
     this.resumeModel();
 
-    this.axIdToAXNode = new Map();
-    this.backendDOMNodeIdToAXNode = new Map();
-    this.backendDOMNodeIdToDOMNode = new Map();
+    this.#axIdToAXNode = new Map();
+    this.#backendDOMNodeIdToAXNode = new Map();
+    this.#backendDOMNodeIdToDOMNode = new Map();
   }
 
   clear(): void {
-    this.axIdToAXNode.clear();
+    this.#axIdToAXNode.clear();
   }
 
   async resumeModel(): Promise<void> {
@@ -230,7 +230,7 @@ export class AccessibilityModel extends SDKModel<void> {
       new AccessibilityNode(this, payload);
     }
 
-    for (const axNode of this.axIdToAXNode.values()) {
+    for (const axNode of this.#axIdToAXNode.values()) {
       for (const axChild of axNode.children()) {
         axChild.setParentNode(axNode);
       }
@@ -243,7 +243,7 @@ export class AccessibilityModel extends SDKModel<void> {
       return;
     }
     const newNodesToTrack = await domModel.pushNodesByBackendIdsToFrontend(backendIds);
-    newNodesToTrack?.forEach((value, key) => this.backendDOMNodeIdToDOMNode.set(key, value));
+    newNodesToTrack?.forEach((value, key) => this.#backendDOMNodeIdToDOMNode.set(key, value));
   }
 
   private createNodesFromPayload(payloadNodes: Protocol.Accessibility.AXNode[]): AccessibilityNode[] {
@@ -315,18 +315,18 @@ export class AccessibilityModel extends SDKModel<void> {
   }
 
   axNodeForId(axId: string): AccessibilityNode|null {
-    return this.axIdToAXNode.get(axId) || null;
+    return this.#axIdToAXNode.get(axId) || null;
   }
 
   setAXNodeForAXId(axId: string, axNode: AccessibilityNode): void {
-    this.axIdToAXNode.set(axId, axNode);
+    this.#axIdToAXNode.set(axId, axNode);
   }
 
   axNodeForDOMNode(domNode: DOMNode|null): AccessibilityNode|null {
     if (!domNode) {
       return null;
     }
-    return this.backendDOMNodeIdToAXNode.get(domNode.backendNodeId()) ?? null;
+    return this.#backendDOMNodeIdToAXNode.get(domNode.backendNodeId()) ?? null;
   }
 
   domNodeforAXNode(axNode: AccessibilityNode): DOMNode|null {
@@ -334,11 +334,11 @@ export class AccessibilityModel extends SDKModel<void> {
     if (!backendDOMNodeId) {
       return null;
     }
-    return this.backendDOMNodeIdToDOMNode.get(backendDOMNodeId) ?? null;
+    return this.#backendDOMNodeIdToDOMNode.get(backendDOMNodeId) ?? null;
   }
 
   setAXNodeForBackendDOMNodeId(backendDOMNodeId: Protocol.DOM.BackendNodeId, axNode: AccessibilityNode): void {
-    this.backendDOMNodeIdToAXNode.set(backendDOMNodeId, axNode);
+    this.#backendDOMNodeIdToAXNode.set(backendDOMNodeId, axNode);
   }
 
   getAgent(): ProtocolProxyApi.AccessibilityApi {

package/front_end/core/sdk/CPUProfileDataModel.ts

@@ -70,12 +70,12 @@ export class CPUProfileDataModel extends ProfileTreeModel {
   lines: any;
   totalHitCount: number;
   profileHead: CPUProfileNode;
-  private idToNode!: Map<number, CPUProfileNode>;
+  #idToNode!: Map<number, CPUProfileNode>;
   gcNode!: CPUProfileNode;
   programNode?: ProfileNode;
   idleNode?: ProfileNode;
-  private stackStartTimes?: Float64Array;
-  private stackChildrenDuration?: Float64Array;
+  #stackStartTimes?: Float64Array;
+  #stackChildrenDuration?: Float64Array;
   constructor(profile: Protocol.Profiler.Profile, target: Target|null) {
     super(target);
     // @ts-ignore Legacy types
@@ -299,8 +299,8 @@ export class CPUProfileDataModel extends ProfileTreeModel {
   }
 
   private buildIdToNodeMap(): void {
-    this.idToNode = new Map();
-    const idToNode = this.idToNode;
+    this.#idToNode = new Map();
+    const idToNode = this.#idToNode;
     const stack = [this.profileHead];
     while (stack.length) {
       const node = (stack.pop() as CPUProfileNode);
@@ -339,7 +339,7 @@ export class CPUProfileDataModel extends ProfileTreeModel {
     if (!this.programNode || samplesCount < 3) {
       return;
     }
-    const idToNode = this.idToNode;
+    const idToNode = this.#idToNode;
     const programNodeId = this.programNode.id;
     const gcNodeId = this.gcNode ? this.gcNode.id : -1;
     const idleNodeId = this.idleNode ? this.idleNode.id : -1;
@@ -383,7 +383,7 @@ export class CPUProfileDataModel extends ProfileTreeModel {
     stopTime = stopTime || Infinity;
     const samples = this.samples;
     const timestamps = this.timestamps;
-    const idToNode = this.idToNode;
+    const idToNode = this.#idToNode;
     const gcNode = this.gcNode;
     const samplesCount = samples.length;
     const startIndex =
@@ -397,14 +397,14 @@ export class CPUProfileDataModel extends ProfileTreeModel {
     // Extra slots for gc being put on top,
     // and one at the bottom to allow safe stackTop-1 access.
     const stackDepth = this.maxDepth + 3;
-    if (!this.stackStartTimes) {
-      this.stackStartTimes = new Float64Array(stackDepth);
+    if (!this.#stackStartTimes) {
+      this.#stackStartTimes = new Float64Array(stackDepth);
     }
-    const stackStartTimes = this.stackStartTimes;
-    if (!this.stackChildrenDuration) {
-      this.stackChildrenDuration = new Float64Array(stackDepth);
+    const stackStartTimes = this.#stackStartTimes;
+    if (!this.#stackChildrenDuration) {
+      this.#stackChildrenDuration = new Float64Array(stackDepth);
     }
-    const stackChildrenDuration = this.stackChildrenDuration;
+    const stackChildrenDuration = this.#stackChildrenDuration;
 
     let node;
     let sampleIndex;
@@ -495,6 +495,6 @@ export class CPUProfileDataModel extends ProfileTreeModel {
   }
 
   nodeByIndex(index: number): CPUProfileNode|null {
-    return this.samples && this.idToNode.get(this.samples[index]) || null;
+    return this.samples && this.#idToNode.get(this.samples[index]) || null;
   }
 }

package/front_end/core/sdk/CPUProfilerModel.ts

@@ -50,38 +50,38 @@ const str_ = i18n.i18n.registerUIStrings('core/sdk/CPUProfilerModel.ts', UIStrin
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolProxyApi.ProfilerDispatcher {
-  private isRecording: boolean;
-  private nextAnonymousConsoleProfileNumber: number;
-  private anonymousConsoleProfileIdToTitle: Map<string, string>;
-  private readonly profilerAgent: ProtocolProxyApi.ProfilerApi;
-  private preciseCoverageDeltaUpdateCallback:
+  #isRecording: boolean;
+  #nextAnonymousConsoleProfileNumber: number;
+  #anonymousConsoleProfileIdToTitle: Map<string, string>;
+  readonly #profilerAgent: ProtocolProxyApi.ProfilerApi;
+  #preciseCoverageDeltaUpdateCallback:
       ((arg0: number, arg1: string, arg2: Array<Protocol.Profiler.ScriptCoverage>) => void)|null;
-  private readonly debuggerModelInternal: DebuggerModel;
+  readonly #debuggerModelInternal: DebuggerModel;
 
   constructor(target: Target) {
     super(target);
-    this.isRecording = false;
-    this.nextAnonymousConsoleProfileNumber = 1;
-    this.anonymousConsoleProfileIdToTitle = new Map();
-    this.profilerAgent = target.profilerAgent();
-    this.preciseCoverageDeltaUpdateCallback = null;
+    this.#isRecording = false;
+    this.#nextAnonymousConsoleProfileNumber = 1;
+    this.#anonymousConsoleProfileIdToTitle = new Map();
+    this.#profilerAgent = target.profilerAgent();
+    this.#preciseCoverageDeltaUpdateCallback = null;
     target.registerProfilerDispatcher(this);
-    this.profilerAgent.invoke_enable();
-    this.debuggerModelInternal = (target.model(DebuggerModel) as DebuggerModel);
+    this.#profilerAgent.invoke_enable();
+    this.#debuggerModelInternal = (target.model(DebuggerModel) as DebuggerModel);
   }
 
   runtimeModel(): RuntimeModel {
-    return this.debuggerModelInternal.runtimeModel();
+    return this.#debuggerModelInternal.runtimeModel();
   }
 
   debuggerModel(): DebuggerModel {
-    return this.debuggerModelInternal;
+    return this.#debuggerModelInternal;
   }
 
   consoleProfileStarted({id, location, title}: Protocol.Profiler.ConsoleProfileStartedEvent): void {
     if (!title) {
-      title = i18nString(UIStrings.profileD, {PH1: this.nextAnonymousConsoleProfileNumber++});
-      this.anonymousConsoleProfileIdToTitle.set(id, title);
+      title = i18nString(UIStrings.profileD, {PH1: this.#nextAnonymousConsoleProfileNumber++});
+      this.#anonymousConsoleProfileIdToTitle.set(id, title);
     }
     const eventData = this.createEventDataFrom(id, location, title);
     this.dispatchEventToListeners(Events.ConsoleProfileStarted, eventData);
@@ -89,8 +89,8 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
 
   consoleProfileFinished({id, location, profile, title}: Protocol.Profiler.ConsoleProfileFinishedEvent): void {
     if (!title) {
-      title = this.anonymousConsoleProfileIdToTitle.get(id);
-      this.anonymousConsoleProfileIdToTitle.delete(id);
+      title = this.#anonymousConsoleProfileIdToTitle.get(id);
+      this.#anonymousConsoleProfileIdToTitle.delete(id);
     }
     // Make sure ProfilesPanel is initialized and CPUProfileType is created.
     Root.Runtime.Runtime.instance().loadModulePromise('profiler').then(() => {
@@ -103,7 +103,7 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
   }
 
   private createEventDataFrom(id: string, scriptLocation: Protocol.Debugger.Location, title?: string): EventData {
-    const debuggerLocation = Location.fromPayload(this.debuggerModelInternal, scriptLocation);
+    const debuggerLocation = Location.fromPayload(this.#debuggerModelInternal, scriptLocation);
     const globalId = this.target().id() + '.' + id;
     return {
       id: globalId,
@@ -114,19 +114,19 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
   }
 
   isRecordingProfile(): boolean {
-    return this.isRecording;
+    return this.#isRecording;
   }
 
   startRecording(): Promise<unknown> {
-    this.isRecording = true;
+    this.#isRecording = true;
     const intervalUs = 100;
-    this.profilerAgent.invoke_setSamplingInterval({interval: intervalUs});
-    return this.profilerAgent.invoke_start();
+    this.#profilerAgent.invoke_setSamplingInterval({interval: intervalUs});
+    return this.#profilerAgent.invoke_start();
   }
 
   stopRecording(): Promise<Protocol.Profiler.Profile|null> {
-    this.isRecording = false;
-    return this.profilerAgent.invoke_stop().then(response => response.profile || null);
+    this.#isRecording = false;
+    return this.#profilerAgent.invoke_stop().then(response => response.profile || null);
   }
 
   startPreciseCoverage(
@@ -135,9 +135,9 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
           ((arg0: number, arg1: string, arg2: Array<Protocol.Profiler.ScriptCoverage>) => void)|
       null): Promise<unknown> {
     const callCount = false;
-    this.preciseCoverageDeltaUpdateCallback = preciseCoverageDeltaUpdateCallback;
+    this.#preciseCoverageDeltaUpdateCallback = preciseCoverageDeltaUpdateCallback;
     const allowUpdatesTriggeredByBackend = true;
-    return this.profilerAgent.invoke_startPreciseCoverage(
+    return this.#profilerAgent.invoke_startPreciseCoverage(
         {callCount, detailed: jsCoveragePerBlock, allowTriggeredUpdates: allowUpdatesTriggeredByBackend});
   }
 
@@ -145,20 +145,20 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
     timestamp: number,
     coverage: Array<Protocol.Profiler.ScriptCoverage>,
   }> {
-    const r = await this.profilerAgent.invoke_takePreciseCoverage();
+    const r = await this.#profilerAgent.invoke_takePreciseCoverage();
     const timestamp = (r && r.timestamp) || 0;
     const coverage = (r && r.result) || [];
     return {timestamp, coverage};
   }
 
   stopPreciseCoverage(): Promise<unknown> {
-    this.preciseCoverageDeltaUpdateCallback = null;
-    return this.profilerAgent.invoke_stopPreciseCoverage();
+    this.#preciseCoverageDeltaUpdateCallback = null;
+    return this.#profilerAgent.invoke_stopPreciseCoverage();
   }
 
   preciseCoverageDeltaUpdate({timestamp, occasion, result}: Protocol.Profiler.PreciseCoverageDeltaUpdateEvent): void {
-    if (this.preciseCoverageDeltaUpdateCallback) {
-      this.preciseCoverageDeltaUpdateCallback(timestamp, occasion, result);
+    if (this.#preciseCoverageDeltaUpdateCallback) {
+      this.#preciseCoverageDeltaUpdateCallback(timestamp, occasion, result);
     }
   }
 }

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -12,11 +12,11 @@ let throttlingManagerInstance: CPUThrottlingManager;
 
 export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<EmulationModel> {
-  private cpuThrottlingRateInternal: number;
+  #cpuThrottlingRateInternal: number;
 
   private constructor() {
     super();
-    this.cpuThrottlingRateInternal = CPUThrottlingRates.NoThrottling;
+    this.#cpuThrottlingRateInternal = CPUThrottlingRates.NoThrottling;
     TargetManager.instance().observeModels(EmulationModel, this);
   }
 
@@ -30,20 +30,20 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   }
 
   cpuThrottlingRate(): number {
-    return this.cpuThrottlingRateInternal;
+    return this.#cpuThrottlingRateInternal;
   }
 
   setCPUThrottlingRate(rate: number): void {
-    this.cpuThrottlingRateInternal = rate;
+    this.#cpuThrottlingRateInternal = rate;
     for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
-      emulationModel.setCPUThrottlingRate(this.cpuThrottlingRateInternal);
+      emulationModel.setCPUThrottlingRate(this.#cpuThrottlingRateInternal);
     }
-    this.dispatchEventToListeners(Events.RateChanged, this.cpuThrottlingRateInternal);
+    this.dispatchEventToListeners(Events.RateChanged, this.#cpuThrottlingRateInternal);
   }
 
   modelAdded(emulationModel: EmulationModel): void {
-    if (this.cpuThrottlingRateInternal !== CPUThrottlingRates.NoThrottling) {
-      emulationModel.setCPUThrottlingRate(this.cpuThrottlingRateInternal);
+    if (this.#cpuThrottlingRateInternal !== CPUThrottlingRates.NoThrottling) {
+      emulationModel.setCPUThrottlingRate(this.#cpuThrottlingRateInternal);
     }
   }
 

package/front_end/core/sdk/CSSFontFace.ts

@@ -5,23 +5,23 @@
 import type * as Protocol from '../../generated/protocol.js';
 
 export class CSSFontFace {
-  private readonly fontFamily: string;
-  private readonly fontVariationAxes: Protocol.CSS.FontVariationAxis[];
-  private readonly fontVariationAxesByTag: Map<string, Protocol.CSS.FontVariationAxis>;
+  readonly #fontFamily: string;
+  readonly #fontVariationAxes: Protocol.CSS.FontVariationAxis[];
+  readonly #fontVariationAxesByTag: Map<string, Protocol.CSS.FontVariationAxis>;
   constructor(payload: Protocol.CSS.FontFace) {
-    this.fontFamily = payload.fontFamily;
-    this.fontVariationAxes = payload.fontVariationAxes || [];
-    this.fontVariationAxesByTag = new Map();
-    for (const axis of this.fontVariationAxes) {
-      this.fontVariationAxesByTag.set(axis.tag, axis);
+    this.#fontFamily = payload.fontFamily;
+    this.#fontVariationAxes = payload.fontVariationAxes || [];
+    this.#fontVariationAxesByTag = new Map();
+    for (const axis of this.#fontVariationAxes) {
+      this.#fontVariationAxesByTag.set(axis.tag, axis);
     }
   }
 
   getFontFamily(): string {
-    return this.fontFamily;
+    return this.#fontFamily;
   }
 
   getVariationAxisByTag(tag: string): Protocol.CSS.FontVariationAxis|undefined {
-    return this.fontVariationAxesByTag.get(tag);
+    return this.#fontVariationAxesByTag.get(tag);
   }
 }