chrome-devtools-frontend 1.0.951864 → 1.0.952284

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -34,27 +34,27 @@ import type {HeapSnapshotHeader, Profile} from './HeapSnapshot.js';
 import type {HeapSnapshotWorkerDispatcher} from './HeapSnapshotWorkerDispatcher.js';
 
 export class HeapSnapshotLoader {
-  private readonly progress: HeapSnapshotProgress;
-  private buffer: string;
-  private dataCallback: ((value: string|PromiseLike<string>) => void)|null;
-  private done: boolean;
+  readonly #progress: HeapSnapshotProgress;
+  #buffer: string;
+  #dataCallback: ((value: string|PromiseLike<string>) => void)|null;
+  #done: boolean;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private snapshot?: {[x: string]: any};
-  private array!: number[]|Uint32Array|null;
-  private arrayIndex!: number;
+  #snapshot?: {[x: string]: any};
+  #array!: number[]|Uint32Array|null;
+  #arrayIndex!: number;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private json?: any;
+  #json?: any;
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private jsonTokenizer?: any;
+  #jsonTokenizer?: any;
   constructor(dispatcher: HeapSnapshotWorkerDispatcher) {
     this.reset();
-    this.progress = new HeapSnapshotProgress(dispatcher);
-    this.buffer = '';
-    this.dataCallback = null;
-    this.done = false;
+    this.#progress = new HeapSnapshotProgress(dispatcher);
+    this.#buffer = '';
+    this.#dataCallback = null;
+    this.#done = false;
     this.parseInput();
   }
 
@@ -63,22 +63,22 @@ export class HeapSnapshotLoader {
   }
 
   private reset(): void {
-    this.json = '';
-    this.snapshot = undefined;
+    this.#json = '';
+    this.#snapshot = undefined;
   }
 
   close(): void {
-    this.done = true;
-    if (this.dataCallback) {
-      this.dataCallback('');
+    this.#done = true;
+    if (this.#dataCallback) {
+      this.#dataCallback('');
     }
   }
 
   buildSnapshot(): JSHeapSnapshot {
-    this.snapshot = this.snapshot || {};
+    this.#snapshot = this.#snapshot || {};
 
-    this.progress.updateStatus('Processing snapshot…');
-    const result = new JSHeapSnapshot((this.snapshot as Profile), this.progress);
+    this.#progress.updateStatus('Processing snapshot…');
+    const result = new JSHeapSnapshot((this.#snapshot as Profile), this.#progress);
     this.reset();
     return result;
   }
@@ -88,26 +88,26 @@ export class HeapSnapshotLoader {
     const char0 = '0'.charCodeAt(0);
     const char9 = '9'.charCodeAt(0);
     const closingBracket = ']'.charCodeAt(0);
-    const length = this.json.length;
+    const length = this.#json.length;
     while (true) {
       while (index < length) {
-        const code = this.json.charCodeAt(index);
+        const code = this.#json.charCodeAt(index);
         if (char0 <= code && code <= char9) {
           break;
         } else if (code === closingBracket) {
-          this.json = this.json.slice(index + 1);
+          this.#json = this.#json.slice(index + 1);
           return false;
         }
         ++index;
       }
       if (index === length) {
-        this.json = '';
+        this.#json = '';
         return true;
       }
       let nextNumber = 0;
       const startIndex = index;
       while (index < length) {
-        const code = this.json.charCodeAt(index);
+        const code = this.#json.charCodeAt(index);
         if (char0 > code || code > char9) {
           break;
         }
@@ -116,73 +116,73 @@ export class HeapSnapshotLoader {
         ++index;
       }
       if (index === length) {
-        this.json = this.json.slice(startIndex);
+        this.#json = this.#json.slice(startIndex);
         return true;
       }
-      if (!this.array) {
+      if (!this.#array) {
         throw new Error('Array not instantiated');
       }
-      this.array[this.arrayIndex++] = nextNumber;
+      this.#array[this.#arrayIndex++] = nextNumber;
     }
   }
 
   private parseStringsArray(): void {
-    this.progress.updateStatus('Parsing strings…');
-    const closingBracketIndex = this.json.lastIndexOf(']');
+    this.#progress.updateStatus('Parsing strings…');
+    const closingBracketIndex = this.#json.lastIndexOf(']');
     if (closingBracketIndex === -1) {
       throw new Error('Incomplete JSON');
     }
-    this.json = this.json.slice(0, closingBracketIndex + 1);
+    this.#json = this.#json.slice(0, closingBracketIndex + 1);
 
-    if (!this.snapshot) {
+    if (!this.#snapshot) {
       throw new Error('No snapshot in parseStringsArray');
     }
-    this.snapshot.strings = JSON.parse(this.json);
+    this.#snapshot.strings = JSON.parse(this.#json);
   }
 
   write(chunk: string): void {
-    this.buffer += chunk;
-    if (!this.dataCallback) {
+    this.#buffer += chunk;
+    if (!this.#dataCallback) {
       return;
     }
-    this.dataCallback(this.buffer);
-    this.dataCallback = null;
-    this.buffer = '';
+    this.#dataCallback(this.#buffer);
+    this.#dataCallback = null;
+    this.#buffer = '';
   }
 
   private fetchChunk(): Promise<string> {
-    return this.done ? Promise.resolve(this.buffer) : new Promise(r => {
-      this.dataCallback = r;
+    return this.#done ? Promise.resolve(this.#buffer) : new Promise(r => {
+      this.#dataCallback = r;
     });
   }
 
   private async findToken(token: string, startIndex?: number): Promise<number> {
     while (true) {
-      const pos = this.json.indexOf(token, startIndex || 0);
+      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();
+      startIndex = this.#json.length - token.length + 1;
+      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);
-    this.json = this.json.slice(bracketIndex + 1);
-    this.array = length ? new Uint32Array(length) : [];
-    this.arrayIndex = 0;
+    this.#json = this.#json.slice(bracketIndex + 1);
+    this.#array = length ? new Uint32Array(length) : [];
+    this.#arrayIndex = 0;
     while (this.parseUintArray()) {
       if (length) {
-        this.progress.updateProgress(title, this.arrayIndex, this.array.length);
+        this.#progress.updateProgress(title, this.#arrayIndex, this.#array.length);
       } else {
-        this.progress.updateStatus(title);
+        this.#progress.updateStatus(title);
       }
-      this.json += await this.fetchChunk();
+      this.#json += await this.fetchChunk();
     }
-    const result = this.array;
-    this.array = null;
+    const result = this.#array;
+    this.#array = null;
     return result;
   }
 
@@ -193,63 +193,64 @@ export class HeapSnapshotLoader {
       throw new Error('Snapshot token not found');
     }
 
-    this.progress.updateStatus('Loading snapshot info…');
-    const json = this.json.slice(snapshotTokenIndex + snapshotToken.length + 1);
-    this.jsonTokenizer = new TextUtils.TextUtils.BalancedJSONTokenizer(metaJSON => {
-      this.json = this.jsonTokenizer.remainder();
-      this.jsonTokenizer = null;
+    this.#progress.updateStatus('Loading snapshot info…');
+    const json = this.#json.slice(snapshotTokenIndex + snapshotToken.length + 1);
+    this.#jsonTokenizer = new TextUtils.TextUtils.BalancedJSONTokenizer(metaJSON => {
+      this.#json = this.#jsonTokenizer.remainder();
+      this.#jsonTokenizer = null;
 
-      this.snapshot = this.snapshot || {};
-      this.snapshot.snapshot = (JSON.parse(metaJSON) as HeapSnapshotHeader);
+      this.#snapshot = this.#snapshot || {};
+      this.#snapshot.snapshot = (JSON.parse(metaJSON) as HeapSnapshotHeader);
     });
-    this.jsonTokenizer.write(json);
-    while (this.jsonTokenizer) {
-      this.jsonTokenizer.write(await this.fetchChunk());
+    this.#jsonTokenizer.write(json);
+    while (this.#jsonTokenizer) {
+      this.#jsonTokenizer.write(await this.fetchChunk());
     }
 
-    this.snapshot = this.snapshot || {};
+    this.#snapshot = this.#snapshot || {};
     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);
+        this.#snapshot.snapshot.meta.node_fields.length * this.#snapshot.snapshot.node_count);
+    this.#snapshot.nodes = (nodes as Uint32Array);
 
     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);
+        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) {
+    if (this.#snapshot.snapshot.trace_function_count) {
       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);
+          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 openBracketIndex = this.json.indexOf('[');
-      const closeBracketIndex = this.json.lastIndexOf(']', nextTokenIndex);
-      this.snapshot.trace_tree = JSON.parse(this.json.substring(openBracketIndex, closeBracketIndex + 1));
-      this.json = this.json.slice(closeBracketIndex + 1);
+      const openBracketIndex = this.#json.indexOf('[');
+      const closeBracketIndex = this.#json.lastIndexOf(']', nextTokenIndex);
+      this.#snapshot.trace_tree = JSON.parse(this.#json.substring(openBracketIndex, closeBracketIndex + 1));
+      this.#json = this.#json.slice(closeBracketIndex + 1);
     }
 
-    if (this.snapshot.snapshot.meta.sample_fields) {
+    if (this.#snapshot.snapshot.meta.sample_fields) {
       const samples = await this.parseArray('"samples"', 'Loading samples…');
-      this.snapshot.samples = (samples as number[]);
+      this.#snapshot.samples = (samples as number[]);
     }
 
-    if (this.snapshot.snapshot.meta['location_fields']) {
+    if (this.#snapshot.snapshot.meta['location_fields']) {
       const locations = await this.parseArray('"locations"', 'Loading locations…');
-      this.snapshot.locations = (locations as number[]);
+      this.#snapshot.locations = (locations as number[]);
     } else {
-      this.snapshot.locations = [];
+      this.#snapshot.locations = [];
     }
 
-    this.progress.updateStatus('Loading strings…');
+    this.#progress.updateStatus('Loading strings…');
     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 = this.#json.slice(bracketIndex);
+    while (!this.#done) {
+      this.#json += await this.fetchChunk();
     }
     this.parseStringsArray();
   }

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotWorkerDispatcher.ts

@@ -41,20 +41,20 @@ interface DispatcherResponse {
 export class HeapSnapshotWorkerDispatcher {
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private objects: any[];
-  private readonly global: Worker;
-  private readonly postMessage: Function;
+  #objects: any[];
+  readonly #global: Worker;
+  readonly #postMessage: Function;
   constructor(globalObject: Worker, postMessage: Function) {
-    this.objects = [];
-    this.global = globalObject;
-    this.postMessage = postMessage;
+    this.#objects = [];
+    this.#global = globalObject;
+    this.#postMessage = postMessage;
   }
 
   private 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
-    let result = (this.global as any);
+    let result = (this.#global as any);
     for (let i = 0; i < path.length; ++i) {
       result = result[path[i]];
     }
@@ -64,7 +64,7 @@ export class HeapSnapshotWorkerDispatcher {
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   sendEvent(name: string, data: any): void {
-    this.postMessage({eventName: name, data: data});
+    this.#postMessage({eventName: name, data: data});
   }
 
   dispatchMessage({data}: {data: HeapSnapshotModel.HeapSnapshotModel.WorkerCommand}): void {
@@ -75,30 +75,30 @@ export class HeapSnapshotWorkerDispatcher {
         case 'create': {
           const constructorFunction = this.findFunction(data.methodName);
           // @ts-ignore
-          this.objects[data.objectId] = new constructorFunction(this);
+          this.#objects[data.objectId] = new constructorFunction(this);
           break;
         }
         case 'dispose': {
-          delete this.objects[data.objectId];
+          delete this.#objects[data.objectId];
           break;
         }
         case 'getter': {
-          const object = this.objects[data.objectId];
+          const object = this.#objects[data.objectId];
           const result = object[data.methodName];
           response.result = result;
           break;
         }
         case 'factory': {
-          const object = this.objects[data.objectId];
+          const object = this.#objects[data.objectId];
           const result = object[data.methodName].apply(object, data.methodArguments);
           if (result) {
-            this.objects[data.newObjectId] = result;
+            this.#objects[data.newObjectId] = result;
           }
           response.result = Boolean(result);
           break;
         }
         case 'method': {
-          const object = this.objects[data.objectId];
+          const object = this.#objects[data.objectId];
           response.result = object[data.methodName].apply(object, data.methodArguments);
           break;
         }
@@ -118,6 +118,6 @@ export class HeapSnapshotWorkerDispatcher {
         response.errorMethodName = data.methodName;
       }
     }
-    this.postMessage(response);
+    this.#postMessage(response);
   }
 }

package/front_end/entrypoints/inspector_main/InspectorMain.ts

@@ -145,20 +145,20 @@ export class FocusDebuggeeActionDelegate implements UI.ActionRegistration.Action
 let nodeIndicatorInstance: NodeIndicator;
 
 export class NodeIndicator implements UI.Toolbar.Provider {
-  private readonly element: Element;
-  private readonly button: UI.Toolbar.ToolbarItem;
+  readonly #element: Element;
+  readonly #button: UI.Toolbar.ToolbarItem;
   private constructor() {
     const element = document.createElement('div');
     const shadowRoot =
         UI.Utils.createShadowRootWithCoreStyles(element, {cssFile: [nodeIconStyles], delegatesFocus: undefined});
-    this.element = shadowRoot.createChild('div', 'node-icon');
+    this.#element = shadowRoot.createChild('div', 'node-icon');
     element.addEventListener(
         'click', () => Host.InspectorFrontendHost.InspectorFrontendHostInstance.openNodeFrontend(), false);
-    this.button = new UI.Toolbar.ToolbarItem(element);
-    this.button.setTitle(i18nString(UIStrings.openDedicatedTools));
+    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));
-    this.button.setVisible(false);
+    this.#button.setVisible(false);
     this.update([]);
   }
   static instance(opts: {
@@ -174,14 +174,14 @@ export class NodeIndicator implements UI.Toolbar.Provider {
 
   private update(targetInfos: Protocol.Target.TargetInfo[]): void {
     const hasNode = Boolean(targetInfos.find(target => target.type === 'node' && !target.attached));
-    this.element.classList.toggle('inactive', !hasNode);
+    this.#element.classList.toggle('inactive', !hasNode);
     if (hasNode) {
-      this.button.setVisible(true);
+      this.#button.setVisible(true);
     }
   }
 
   item(): UI.Toolbar.ToolbarItem|null {
-    return this.button;
+    return this.#button;
   }
 }
 
@@ -205,20 +205,20 @@ export class SourcesPanelIndicator {
 }
 
 export class BackendSettingsSync implements SDK.TargetManager.Observer {
-  private readonly autoAttachSetting: Common.Settings.Setting<boolean>;
-  private readonly adBlockEnabledSetting: Common.Settings.Setting<boolean>;
-  private readonly emulatePageFocusSetting: Common.Settings.Setting<boolean>;
+  readonly #autoAttachSetting: Common.Settings.Setting<boolean>;
+  readonly #adBlockEnabledSetting: Common.Settings.Setting<boolean>;
+  readonly #emulatePageFocusSetting: Common.Settings.Setting<boolean>;
 
   constructor() {
-    this.autoAttachSetting = Common.Settings.Settings.instance().moduleSetting('autoAttachToCreatedPages');
-    this.autoAttachSetting.addChangeListener(this.updateAutoAttach, this);
+    this.#autoAttachSetting = Common.Settings.Settings.instance().moduleSetting('autoAttachToCreatedPages');
+    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 = Common.Settings.Settings.instance().moduleSetting('network.adBlockingEnabled');
+    this.#adBlockEnabledSetting.addChangeListener(this.update, this);
 
-    this.emulatePageFocusSetting = Common.Settings.Settings.instance().moduleSetting('emulatePageFocus');
-    this.emulatePageFocusSetting.addChangeListener(this.update, this);
+    this.#emulatePageFocusSetting = Common.Settings.Settings.instance().moduleSetting('emulatePageFocus');
+    this.#emulatePageFocusSetting.addChangeListener(this.update, this);
 
     SDK.TargetManager.TargetManager.instance().observeTargets(this);
   }
@@ -227,12 +227,12 @@ export class BackendSettingsSync implements SDK.TargetManager.Observer {
     if (target.type() !== SDK.Target.Type.Frame || target.parentTarget()) {
       return;
     }
-    target.pageAgent().invoke_setAdBlockingEnabled({enabled: this.adBlockEnabledSetting.get()});
-    target.emulationAgent().invoke_setFocusEmulationEnabled({enabled: this.emulatePageFocusSetting.get()});
+    target.pageAgent().invoke_setAdBlockingEnabled({enabled: this.#adBlockEnabledSetting.get()});
+    target.emulationAgent().invoke_setFocusEmulationEnabled({enabled: this.#emulatePageFocusSetting.get()});
   }
 
   private updateAutoAttach(): void {
-    Host.InspectorFrontendHost.InspectorFrontendHostInstance.setOpenNewWindowForPopups(this.autoAttachSetting.get());
+    Host.InspectorFrontendHost.InspectorFrontendHostInstance.setOpenNewWindowForPopups(this.#autoAttachSetting.get());
   }
 
   private update(): void {

package/front_end/entrypoints/main/ExecutionContextSelector.ts

@@ -7,10 +7,10 @@ import type * as Common from '../../core/common/common.js';
 import type * as UI from '../../ui/legacy/legacy.js';
 
 export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObserver<SDK.RuntimeModel.RuntimeModel> {
-  private targetManager: SDK.TargetManager.TargetManager;
-  private context: UI.Context.Context;
-  private lastSelectedContextId?: string;
-  private ignoreContextChanged?: boolean;
+  #targetManager: SDK.TargetManager.TargetManager;
+  #context: UI.Context.Context;
+  #lastSelectedContextId?: string;
+  #ignoreContextChanged?: boolean;
 
   constructor(targetManager: SDK.TargetManager.TargetManager, context: UI.Context.Context) {
     context.addFlavorChangeListener(SDK.RuntimeModel.ExecutionContext, this.executionContextChanged, this);
@@ -25,8 +25,8 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     targetManager.addModelListener(
         SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextOrderChanged,
         this.onExecutionContextOrderChanged, this);
-    this.targetManager = targetManager;
-    this.context = context;
+    this.#targetManager = targetManager;
+    this.#context = context;
     targetManager.observeModels(SDK.RuntimeModel.RuntimeModel, this);
   }
 
@@ -37,21 +37,21 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
 
     function deferred(this: ExecutionContextSelector): void {
       // We always want the second context for the service worker targets.
-      if (!this.context.flavor(SDK.Target.Target)) {
-        this.context.setFlavor(SDK.Target.Target, runtimeModel.target());
+      if (!this.#context.flavor(SDK.Target.Target)) {
+        this.#context.setFlavor(SDK.Target.Target, runtimeModel.target());
       }
     }
   }
 
   modelRemoved(runtimeModel: SDK.RuntimeModel.RuntimeModel): void {
-    const currentExecutionContext = this.context.flavor(SDK.RuntimeModel.ExecutionContext);
+    const currentExecutionContext = this.#context.flavor(SDK.RuntimeModel.ExecutionContext);
     if (currentExecutionContext && currentExecutionContext.runtimeModel === runtimeModel) {
       this.currentExecutionContextGone();
     }
 
-    const models = this.targetManager.models(SDK.RuntimeModel.RuntimeModel);
-    if (this.context.flavor(SDK.Target.Target) === runtimeModel.target() && models.length) {
-      this.context.setFlavor(SDK.Target.Target, models[0].target());
+    const models = this.#targetManager.models(SDK.RuntimeModel.RuntimeModel);
+    if (this.#context.flavor(SDK.Target.Target) === runtimeModel.target() && models.length) {
+      this.#context.setFlavor(SDK.Target.Target, models[0].target());
     }
   }
 
@@ -59,9 +59,9 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     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.#context.setFlavor(SDK.Target.Target, newContext.target());
+      if (!this.#ignoreContextChanged) {
+        this.#lastSelectedContextId = this.contextPersistentId(newContext);
       }
     }
   }
@@ -71,7 +71,7 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
   }
 
   private targetChanged({data: newTarget}: Common.EventTarget.EventTargetEvent<SDK.Target.Target|null>): void {
-    const currentContext = this.context.flavor(SDK.RuntimeModel.ExecutionContext);
+    const currentContext = this.#context.flavor(SDK.RuntimeModel.ExecutionContext);
 
     if (!newTarget || (currentContext && currentContext.target() === newTarget)) {
       return;
@@ -94,16 +94,16 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
         newContext = executionContexts[i];
       }
     }
-    this.ignoreContextChanged = true;
-    this.context.setFlavor(SDK.RuntimeModel.ExecutionContext, newContext || executionContexts[0]);
-    this.ignoreContextChanged = false;
+    this.#ignoreContextChanged = true;
+    this.#context.setFlavor(SDK.RuntimeModel.ExecutionContext, newContext || executionContexts[0]);
+    this.#ignoreContextChanged = false;
   }
 
   private shouldSwitchToContext(executionContext: SDK.RuntimeModel.ExecutionContext): boolean {
-    if (this.lastSelectedContextId && this.lastSelectedContextId === this.contextPersistentId(executionContext)) {
+    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 {
@@ -126,7 +126,7 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
   private onExecutionContextDestroyed(event: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext>):
       void {
     const executionContext = event.data;
-    if (this.context.flavor(SDK.RuntimeModel.ExecutionContext) === executionContext) {
+    if (this.#context.flavor(SDK.RuntimeModel.ExecutionContext) === executionContext) {
       this.currentExecutionContextGone();
     }
   }
@@ -143,17 +143,17 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
   }
 
   private 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;
+    if (!this.#context.flavor(SDK.RuntimeModel.ExecutionContext) || this.shouldSwitchToContext(executionContext)) {
+      this.#ignoreContextChanged = true;
+      this.#context.setFlavor(SDK.RuntimeModel.ExecutionContext, executionContext);
+      this.#ignoreContextChanged = false;
       return true;
     }
     return false;
   }
 
   private currentExecutionContextGone(): void {
-    const runtimeModels = this.targetManager.models(SDK.RuntimeModel.RuntimeModel);
+    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();
@@ -173,8 +173,8 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
         }
       }
     }
-    this.ignoreContextChanged = true;
-    this.context.setFlavor(SDK.RuntimeModel.ExecutionContext, newContext);
-    this.ignoreContextChanged = false;
+    this.#ignoreContextChanged = true;
+    this.#context.setFlavor(SDK.RuntimeModel.ExecutionContext, newContext);
+    this.#ignoreContextChanged = false;
   }
 }