chrome-devtools-frontend 1.0.950971 → 1.0.952403

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -34,80 +34,80 @@ 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.parseInput();
+    this.#reset();
+    this.#progress = new HeapSnapshotProgress(dispatcher);
+    this.#buffer = '';
+    this.#dataCallback = null;
+    this.#done = false;
+    this.#parseInput();
   }
 
   dispose(): void {
-    this.reset();
+    this.#reset();
   }
 
-  private reset(): void {
-    this.json = '';
-    this.snapshot = undefined;
+  #reset(): void {
+    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.reset();
+    this.#progress.updateStatus('Processing snapshot…');
+    const result = new JSHeapSnapshot((this.#snapshot as Profile), this.#progress);
+    this.#reset();
     return result;
   }
 
-  private parseUintArray(): boolean {
+  #parseUintArray(): boolean {
     let index = 0;
     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,141 +116,142 @@ 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(']');
+  #parseStringsArray(): void {
+    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;
+  #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);
+      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;
-    while (this.parseUintArray()) {
+  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()) {
       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;
   }
 
-  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');
     }
 
-    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 || {};
-    const nodes = await this.parseArray(
+    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(
+    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) {
-      const traceFunctionInfos = await this.parseArray(
+    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 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);
     }
 
-    if (this.snapshot.snapshot.meta.sample_fields) {
-      const samples = await this.parseArray('"samples"', 'Loading samples…');
-      this.snapshot.samples = (samples as number[]);
+    if (this.#snapshot.snapshot.meta.sample_fields) {
+      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…');
-      this.snapshot.locations = (locations as number[]);
+    if (this.#snapshot.snapshot.meta['location_fields']) {
+      const locations = await this.#parseArray('"locations"', 'Loading locations…');
+      this.#snapshot.locations = (locations as number[]);
     } else {
-      this.snapshot.locations = [];
+      this.#snapshot.locations = [];
     }
 
-    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.#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.parseStringsArray();
+    this.#parseStringsArray();
   }
 }

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotWorkerDispatcher.ts

@@ -41,30 +41,30 @@ 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 {
+  #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]];
     }
-    return /** @type {!Function} */ result as Function;
+    return result as Function;
   }
 
   // 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 {
@@ -73,32 +73,32 @@ 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);
+          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,21 +145,21 @@ 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.update([]);
+        SDK.TargetManager.Events.AvailableTargetsChanged, event => this.#update(event.data));
+    this.#button.setVisible(false);
+    this.#update([]);
   }
   static instance(opts: {
     forceNew: boolean|null,
@@ -172,16 +172,16 @@ 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);
+    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,44 +205,44 @@ 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.updateAutoAttach();
+    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);
   }
 
-  private updateTarget(target: SDK.Target.Target): void {
+  #updateTarget(target: SDK.Target.Target): void {
     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());
+  #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 {