chrome-devtools-frontend 1.0.952284 → 1.0.952865

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -50,19 +50,19 @@ export class HeapSnapshotLoader {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   #jsonTokenizer?: any;
   constructor(dispatcher: HeapSnapshotWorkerDispatcher) {
-    this.reset();
+    this.#reset();
     this.#progress = new HeapSnapshotProgress(dispatcher);
     this.#buffer = '';
     this.#dataCallback = null;
     this.#done = false;
-    this.parseInput();
+    this.#parseInput();
   }
 
   dispose(): void {
-    this.reset();
+    this.#reset();
   }
 
-  private reset(): void {
+  #reset(): void {
     this.#json = '';
     this.#snapshot = undefined;
   }
@@ -79,11 +79,11 @@ export class HeapSnapshotLoader {
 
     this.#progress.updateStatus('Processing snapshot…');
     const result = new JSHeapSnapshot((this.#snapshot as Profile), this.#progress);
-    this.reset();
+    this.#reset();
     return result;
   }
 
-  private parseUintArray(): boolean {
+  #parseUintArray(): boolean {
     let index = 0;
     const char0 = '0'.charCodeAt(0);
     const char9 = '9'.charCodeAt(0);
@@ -126,7 +126,7 @@ export class HeapSnapshotLoader {
     }
   }
 
-  private parseStringsArray(): void {
+  #parseStringsArray(): void {
     this.#progress.updateStatus('Parsing strings…');
     const closingBracketIndex = this.#json.lastIndexOf(']');
     if (closingBracketIndex === -1) {
@@ -150,45 +150,45 @@ export class HeapSnapshotLoader {
     this.#buffer = '';
   }
 
-  private fetchChunk(): Promise<string> {
+  #fetchChunk(): Promise<string> {
     return this.#done ? Promise.resolve(this.#buffer) : new Promise(r => {
       this.#dataCallback = r;
     });
   }
 
-  private async findToken(token: string, startIndex?: number): Promise<number> {
+  async #findToken(token: string, startIndex?: number): Promise<number> {
     while (true) {
       const pos = this.#json.indexOf(token, startIndex || 0);
       if (pos !== -1) {
         return pos;
       }
       startIndex = this.#json.length - token.length + 1;
-      this.#json += await this.fetchChunk();
+      this.#json += await this.#fetchChunk();
     }
   }
 
-  private async parseArray(name: string, title: string, length?: number): Promise<number[]|Uint32Array> {
-    const nameIndex = await this.findToken(name);
-    const bracketIndex = await this.findToken('[', nameIndex);
+  async #parseArray(name: string, title: string, length?: number): Promise<number[]|Uint32Array> {
+    const nameIndex = await this.#findToken(name);
+    const bracketIndex = await this.#findToken('[', nameIndex);
     this.#json = this.#json.slice(bracketIndex + 1);
     this.#array = length ? new Uint32Array(length) : [];
     this.#arrayIndex = 0;
-    while (this.parseUintArray()) {
+    while (this.#parseUintArray()) {
       if (length) {
         this.#progress.updateProgress(title, this.#arrayIndex, this.#array.length);
       } else {
         this.#progress.updateStatus(title);
       }
-      this.#json += await this.fetchChunk();
+      this.#json += await this.#fetchChunk();
     }
     const result = this.#array;
     this.#array = null;
     return result;
   }
 
-  private async parseInput(): Promise<void> {
+  async #parseInput(): Promise<void> {
     const snapshotToken = '"snapshot"';
-    const snapshotTokenIndex = await this.findToken(snapshotToken);
+    const snapshotTokenIndex = await this.#findToken(snapshotToken);
     if (snapshotTokenIndex === -1) {
       throw new Error('Snapshot token not found');
     }
@@ -204,29 +204,29 @@ export class HeapSnapshotLoader {
     });
     this.#jsonTokenizer.write(json);
     while (this.#jsonTokenizer) {
-      this.#jsonTokenizer.write(await this.fetchChunk());
+      this.#jsonTokenizer.write(await this.#fetchChunk());
     }
 
     this.#snapshot = this.#snapshot || {};
-    const nodes = await this.parseArray(
+    const nodes = await this.#parseArray(
         '"nodes"', 'Loading nodes… {PH1}%',
         this.#snapshot.snapshot.meta.node_fields.length * this.#snapshot.snapshot.node_count);
     this.#snapshot.nodes = (nodes as Uint32Array);
 
-    const edges = await this.parseArray(
+    const edges = await this.#parseArray(
         '"edges"', 'Loading edges… {PH1}%',
         this.#snapshot.snapshot.meta.edge_fields.length * this.#snapshot.snapshot.edge_count);
     this.#snapshot.edges = (edges as Uint32Array);
 
     if (this.#snapshot.snapshot.trace_function_count) {
-      const traceFunctionInfos = await this.parseArray(
+      const traceFunctionInfos = await this.#parseArray(
           '"trace_function_infos"', 'Loading allocation traces… {PH1}%',
           this.#snapshot.snapshot.meta.trace_function_info_fields.length *
               this.#snapshot.snapshot.trace_function_count);
       this.#snapshot.trace_function_infos = (traceFunctionInfos as Uint32Array);
 
-      const thisTokenEndIndex = await this.findToken(':');
-      const nextTokenIndex = await this.findToken('"', thisTokenEndIndex);
+      const thisTokenEndIndex = await this.#findToken(':');
+      const nextTokenIndex = await this.#findToken('"', thisTokenEndIndex);
       const openBracketIndex = this.#json.indexOf('[');
       const closeBracketIndex = this.#json.lastIndexOf(']', nextTokenIndex);
       this.#snapshot.trace_tree = JSON.parse(this.#json.substring(openBracketIndex, closeBracketIndex + 1));
@@ -234,24 +234,24 @@ export class HeapSnapshotLoader {
     }
 
     if (this.#snapshot.snapshot.meta.sample_fields) {
-      const samples = await this.parseArray('"samples"', 'Loading samples…');
+      const samples = await this.#parseArray('"samples"', 'Loading samples…');
       this.#snapshot.samples = (samples as number[]);
     }
 
     if (this.#snapshot.snapshot.meta['location_fields']) {
-      const locations = await this.parseArray('"locations"', 'Loading locations…');
+      const locations = await this.#parseArray('"locations"', 'Loading locations…');
       this.#snapshot.locations = (locations as number[]);
     } else {
       this.#snapshot.locations = [];
     }
 
     this.#progress.updateStatus('Loading strings…');
-    const stringsTokenIndex = await this.findToken('"strings"');
-    const bracketIndex = await this.findToken('[', stringsTokenIndex);
+    const stringsTokenIndex = await this.#findToken('"strings"');
+    const bracketIndex = await this.#findToken('[', stringsTokenIndex);
     this.#json = this.#json.slice(bracketIndex);
     while (!this.#done) {
-      this.#json += await this.fetchChunk();
+      this.#json += await this.#fetchChunk();
     }
-    this.parseStringsArray();
+    this.#parseStringsArray();
   }
 }

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotWorkerDispatcher.ts

@@ -50,7 +50,7 @@ export class HeapSnapshotWorkerDispatcher {
     this.#postMessage = postMessage;
   }
 
-  private findFunction(name: string): Function {
+  #findFunction(name: string): Function {
     const path = name.split('.');
     // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -73,7 +73,7 @@ export class HeapSnapshotWorkerDispatcher {
     try {
       switch (data.disposition) {
         case 'create': {
-          const constructorFunction = this.findFunction(data.methodName);
+          const constructorFunction = this.#findFunction(data.methodName);
           // @ts-ignore
           this.#objects[data.objectId] = new constructorFunction(this);
           break;

package/front_end/entrypoints/inspector_main/InspectorMain.ts

@@ -157,9 +157,9 @@ export class NodeIndicator implements UI.Toolbar.Provider {
     this.#button = new UI.Toolbar.ToolbarItem(element);
     this.#button.setTitle(i18nString(UIStrings.openDedicatedTools));
     SDK.TargetManager.TargetManager.instance().addEventListener(
-        SDK.TargetManager.Events.AvailableTargetsChanged, event => this.update(event.data));
+        SDK.TargetManager.Events.AvailableTargetsChanged, event => this.#update(event.data));
     this.#button.setVisible(false);
-    this.update([]);
+    this.#update([]);
   }
   static instance(opts: {
     forceNew: boolean|null,
@@ -172,7 +172,7 @@ export class NodeIndicator implements UI.Toolbar.Provider {
     return nodeIndicatorInstance;
   }
 
-  private update(targetInfos: Protocol.Target.TargetInfo[]): void {
+  #update(targetInfos: Protocol.Target.TargetInfo[]): void {
     const hasNode = Boolean(targetInfos.find(target => target.type === 'node' && !target.attached));
     this.#element.classList.toggle('inactive', !hasNode);
     if (hasNode) {
@@ -211,19 +211,19 @@ export class BackendSettingsSync implements SDK.TargetManager.Observer {
 
   constructor() {
     this.#autoAttachSetting = Common.Settings.Settings.instance().moduleSetting('autoAttachToCreatedPages');
-    this.#autoAttachSetting.addChangeListener(this.updateAutoAttach, this);
-    this.updateAutoAttach();
+    this.#autoAttachSetting.addChangeListener(this.#updateAutoAttach, this);
+    this.#updateAutoAttach();
 
     this.#adBlockEnabledSetting = Common.Settings.Settings.instance().moduleSetting('network.adBlockingEnabled');
-    this.#adBlockEnabledSetting.addChangeListener(this.update, this);
+    this.#adBlockEnabledSetting.addChangeListener(this.#update, this);
 
     this.#emulatePageFocusSetting = Common.Settings.Settings.instance().moduleSetting('emulatePageFocus');
-    this.#emulatePageFocusSetting.addChangeListener(this.update, this);
+    this.#emulatePageFocusSetting.addChangeListener(this.#update, this);
 
     SDK.TargetManager.TargetManager.instance().observeTargets(this);
   }
 
-  private updateTarget(target: SDK.Target.Target): void {
+  #updateTarget(target: SDK.Target.Target): void {
     if (target.type() !== SDK.Target.Type.Frame || target.parentTarget()) {
       return;
     }
@@ -231,18 +231,18 @@ export class BackendSettingsSync implements SDK.TargetManager.Observer {
     target.emulationAgent().invoke_setFocusEmulationEnabled({enabled: this.#emulatePageFocusSetting.get()});
   }
 
-  private updateAutoAttach(): void {
+  #updateAutoAttach(): void {
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.setOpenNewWindowForPopups(this.#autoAttachSetting.get());
   }
 
-  private update(): void {
+  #update(): void {
     for (const target of SDK.TargetManager.TargetManager.instance().targets()) {
-      this.updateTarget(target);
+      this.#updateTarget(target);
     }
   }
 
   targetAdded(target: SDK.Target.Target): void {
-    this.updateTarget(target);
+    this.#updateTarget(target);
   }
 
   targetRemoved(_target: SDK.Target.Target): void {

package/front_end/entrypoints/inspector_main/RenderingOptions.ts

@@ -218,77 +218,77 @@ export class RenderingOptionsView extends UI.Widget.VBox {
   private constructor() {
     super(true);
 
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.paintFlashing), i18nString(UIStrings.highlightsAreasOfThePageGreen),
         Common.Settings.Settings.instance().moduleSetting('showPaintRects'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.layoutShiftRegions), i18nString(UIStrings.highlightsAreasOfThePageBlueThat),
         Common.Settings.Settings.instance().moduleSetting('showLayoutShiftRegions'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.layerBorders), i18nString(UIStrings.showsLayerBordersOrangeoliveAnd),
         Common.Settings.Settings.instance().moduleSetting('showDebugBorders'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.frameRenderingStats), i18nString(UIStrings.plotsFrameThroughputDropped),
         Common.Settings.Settings.instance().moduleSetting('showFPSCounter'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.scrollingPerformanceIssues), i18nString(UIStrings.highlightsElementsTealThatCan),
         Common.Settings.Settings.instance().moduleSetting('showScrollBottleneckRects'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.highlightAdFrames), i18nString(UIStrings.highlightsFramesRedDetectedToBe),
         Common.Settings.Settings.instance().moduleSetting('showAdHighlights'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.coreWebVitals), i18nString(UIStrings.showsAnOverlayWithCoreWebVitals),
         Common.Settings.Settings.instance().moduleSetting('showWebVitals'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.disableLocalFonts), i18nString(UIStrings.disablesLocalSourcesInFontface),
         Common.Settings.Settings.instance().moduleSetting('localFontsDisabled'));
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.emulateAFocusedPage), i18nString(UIStrings.emulatesAFocusedPage),
         Common.Settings.Settings.instance().moduleSetting('emulatePageFocus'));
     this.contentElement.createChild('div').classList.add('panel-section-separator');
 
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.forcesMediaTypeForTestingPrint),
         Common.Settings.Settings.instance().moduleSetting('emulatedCSSMedia'));
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.forcesCssPreferscolorschemeMedia),
         Common.Settings.Settings.instance().moduleSetting('emulatedCSSMediaFeaturePrefersColorScheme'));
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.forcesCssForcedColors),
         Common.Settings.Settings.instance().moduleSetting('emulatedCSSMediaFeatureForcedColors'));
     if (supportsPrefersContrast()) {
-      this.appendSelect(
+      this.#appendSelect(
           i18nString(UIStrings.forcesCssPreferscontrastMedia),
           Common.Settings.Settings.instance().moduleSetting('emulatedCSSMediaFeaturePrefersContrast'));
     }
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.forcesCssPrefersreducedmotion),
         Common.Settings.Settings.instance().moduleSetting('emulatedCSSMediaFeaturePrefersReducedMotion'));
     if (supportsPrefersReducedData()) {
-      this.appendSelect(
+      this.#appendSelect(
           i18nString(UIStrings.forcesCssPrefersreduceddataMedia),
           Common.Settings.Settings.instance().moduleSetting('emulatedCSSMediaFeaturePrefersReducedData'));
     }
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.forcesCssColorgamutMediaFeature),
         Common.Settings.Settings.instance().moduleSetting('emulatedCSSMediaFeatureColorGamut'));
     this.contentElement.createChild('div').classList.add('panel-section-separator');
 
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.forcesVisionDeficiencyEmulation),
         Common.Settings.Settings.instance().moduleSetting('emulatedVisionDeficiency'));
 
     this.contentElement.createChild('div').classList.add('panel-section-separator');
-    this.appendSelect(
+    this.#appendSelect(
         i18nString(UIStrings.emulatesAutoDarkMode),
         Common.Settings.Settings.instance().moduleSetting('emulateAutoDarkMode'));
     this.contentElement.createChild('div').classList.add('panel-section-separator');
 
-    this.appendCheckbox(
+    this.#appendCheckbox(
         i18nString(UIStrings.disableAvifImageFormat), i18nString(UIStrings.requiresAPageReloadToApplyAnd),
         Common.Settings.Settings.instance().moduleSetting('avifFormatDisabled'));
 
-    const webpCheckbox = this.appendCheckbox(
+    const webpCheckbox = this.#appendCheckbox(
         i18nString(UIStrings.disableWebpImageFormat), i18nString(UIStrings.requiresAPageReloadToApplyAnd),
         Common.Settings.Settings.instance().moduleSetting('webpFormatDisabled'));
 
@@ -298,7 +298,7 @@ export class RenderingOptionsView extends UI.Widget.VBox {
       if (!hasSupport) {
         return;
       }
-      webpCheckbox.before(this.createCheckbox(
+      webpCheckbox.before(this.#createCheckbox(
           i18nString(UIStrings.disableJpegXlImageFormat), i18nString(UIStrings.requiresAPageReloadToApplyAnd),
           Common.Settings.Settings.instance().moduleSetting('jpegXlFormatDisabled')));
     });
@@ -315,23 +315,23 @@ export class RenderingOptionsView extends UI.Widget.VBox {
     return renderingOptionsViewInstance;
   }
 
-  private createCheckbox(label: string, subtitle: string, setting: Common.Settings.Setting<boolean>):
+  #createCheckbox(label: string, subtitle: string, setting: Common.Settings.Setting<boolean>):
       UI.UIUtils.CheckboxLabel {
     const checkboxLabel = UI.UIUtils.CheckboxLabel.create(label, false, subtitle);
     UI.SettingsUI.bindCheckbox(checkboxLabel.checkboxElement, setting);
     return checkboxLabel;
   }
 
-  private appendCheckbox(label: string, subtitle: string, setting: Common.Settings.Setting<boolean>):
+  #appendCheckbox(label: string, subtitle: string, setting: Common.Settings.Setting<boolean>):
       UI.UIUtils.CheckboxLabel {
-    const checkbox = this.createCheckbox(label, subtitle, setting);
+    const checkbox = this.#createCheckbox(label, subtitle, setting);
     this.contentElement.appendChild(checkbox);
     return checkbox;
   }
 
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private appendSelect(label: string, setting: Common.Settings.Setting<any>): void {
+  #appendSelect(label: string, setting: Common.Settings.Setting<any>): void {
     const control = UI.SettingsUI.createControlForSetting(setting, label);
     if (control) {
       this.contentElement.appendChild(control);

package/front_end/entrypoints/main/ExecutionContextSelector.ts

@@ -13,18 +13,18 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
   #ignoreContextChanged?: boolean;
 
   constructor(targetManager: SDK.TargetManager.TargetManager, context: UI.Context.Context) {
-    context.addFlavorChangeListener(SDK.RuntimeModel.ExecutionContext, this.executionContextChanged, this);
-    context.addFlavorChangeListener(SDK.Target.Target, this.targetChanged, this);
+    context.addFlavorChangeListener(SDK.RuntimeModel.ExecutionContext, this.#executionContextChanged, this);
+    context.addFlavorChangeListener(SDK.Target.Target, this.#targetChanged, this);
 
     targetManager.addModelListener(
-        SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextCreated, this.onExecutionContextCreated,
+        SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextCreated, this.#onExecutionContextCreated,
         this);
     targetManager.addModelListener(
         SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextDestroyed,
-        this.onExecutionContextDestroyed, this);
+        this.#onExecutionContextDestroyed, this);
     targetManager.addModelListener(
         SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextOrderChanged,
-        this.onExecutionContextOrderChanged, this);
+        this.#onExecutionContextOrderChanged, this);
     this.#targetManager = targetManager;
     this.#context = context;
     targetManager.observeModels(SDK.RuntimeModel.RuntimeModel, this);
@@ -46,7 +46,7 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
   modelRemoved(runtimeModel: SDK.RuntimeModel.RuntimeModel): void {
     const currentExecutionContext = this.#context.flavor(SDK.RuntimeModel.ExecutionContext);
     if (currentExecutionContext && currentExecutionContext.runtimeModel === runtimeModel) {
-      this.currentExecutionContextGone();
+      this.#currentExecutionContextGone();
     }
 
     const models = this.#targetManager.models(SDK.RuntimeModel.RuntimeModel);
@@ -55,22 +55,22 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     }
   }
 
-  private executionContextChanged({
+  #executionContextChanged({
     data: newContext,
   }: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext|null>): void {
     if (newContext) {
       this.#context.setFlavor(SDK.Target.Target, newContext.target());
       if (!this.#ignoreContextChanged) {
-        this.#lastSelectedContextId = this.contextPersistentId(newContext);
+        this.#lastSelectedContextId = this.#contextPersistentId(newContext);
       }
     }
   }
 
-  private contextPersistentId(executionContext: SDK.RuntimeModel.ExecutionContext): string {
+  #contextPersistentId(executionContext: SDK.RuntimeModel.ExecutionContext): string {
     return executionContext.isDefault ? executionContext.target().name() + ':' + executionContext.frameId : '';
   }
 
-  private targetChanged({data: newTarget}: Common.EventTarget.EventTargetEvent<SDK.Target.Target|null>): void {
+  #targetChanged({data: newTarget}: Common.EventTarget.EventTargetEvent<SDK.Target.Target|null>): void {
     const currentContext = this.#context.flavor(SDK.RuntimeModel.ExecutionContext);
 
     if (!newTarget || (currentContext && currentContext.target() === newTarget)) {
@@ -85,12 +85,12 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
 
     let newContext: SDK.RuntimeModel.ExecutionContext|null = null;
     for (let i = 0; i < executionContexts.length && !newContext; ++i) {
-      if (this.shouldSwitchToContext(executionContexts[i])) {
+      if (this.#shouldSwitchToContext(executionContexts[i])) {
         newContext = executionContexts[i];
       }
     }
     for (let i = 0; i < executionContexts.length && !newContext; ++i) {
-      if (this.isDefaultContext(executionContexts[i])) {
+      if (this.#isDefaultContext(executionContexts[i])) {
         newContext = executionContexts[i];
       }
     }
@@ -99,14 +99,14 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     this.#ignoreContextChanged = false;
   }
 
-  private shouldSwitchToContext(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
-    if (this.#lastSelectedContextId && this.#lastSelectedContextId === this.contextPersistentId(executionContext)) {
+  #shouldSwitchToContext(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
+    if (this.#lastSelectedContextId && this.#lastSelectedContextId === this.#contextPersistentId(executionContext)) {
       return true;
     }
-    return !this.#lastSelectedContextId && this.isDefaultContext(executionContext);
+    return !this.#lastSelectedContextId && this.#isDefaultContext(executionContext);
   }
 
-  private isDefaultContext(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
+  #isDefaultContext(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
     if (!executionContext.isDefault || !executionContext.frameId) {
       return false;
     }
@@ -118,32 +118,29 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     return Boolean(frame?.isTopFrame());
   }
 
-  private onExecutionContextCreated(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext>):
-      void {
-    this.switchContextIfNecessary(event.data);
+  #onExecutionContextCreated(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext>): void {
+    this.#switchContextIfNecessary(event.data);
   }
 
-  private onExecutionContextDestroyed(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext>):
-      void {
+  #onExecutionContextDestroyed(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext>): void {
     const executionContext = event.data;
     if (this.#context.flavor(SDK.RuntimeModel.ExecutionContext) === executionContext) {
-      this.currentExecutionContextGone();
+      this.#currentExecutionContextGone();
     }
   }
 
-  private onExecutionContextOrderChanged(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.RuntimeModel>):
-      void {
+  #onExecutionContextOrderChanged(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.RuntimeModel>): void {
     const runtimeModel = event.data;
     const executionContexts = runtimeModel.executionContexts();
     for (let i = 0; i < executionContexts.length; i++) {
-      if (this.switchContextIfNecessary(executionContexts[i])) {
+      if (this.#switchContextIfNecessary(executionContexts[i])) {
         break;
       }
     }
   }
 
-  private switchContextIfNecessary(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
-    if (!this.#context.flavor(SDK.RuntimeModel.ExecutionContext) || this.shouldSwitchToContext(executionContext)) {
+  #switchContextIfNecessary(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
+    if (!this.#context.flavor(SDK.RuntimeModel.ExecutionContext) || this.#shouldSwitchToContext(executionContext)) {
       this.#ignoreContextChanged = true;
       this.#context.setFlavor(SDK.RuntimeModel.ExecutionContext, executionContext);
       this.#ignoreContextChanged = false;
@@ -152,13 +149,13 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     return false;
   }
 
-  private currentExecutionContextGone(): void {
+  #currentExecutionContextGone(): void {
     const runtimeModels = this.#targetManager.models(SDK.RuntimeModel.RuntimeModel);
     let newContext: SDK.RuntimeModel.ExecutionContext|null = null;
     for (let i = 0; i < runtimeModels.length && !newContext; ++i) {
       const executionContexts = runtimeModels[i].executionContexts();
       for (const executionContext of executionContexts) {
-        if (this.isDefaultContext(executionContext)) {
+        if (this.#isDefaultContext(executionContext)) {
           newContext = executionContext;
           break;
         }