chrome-devtools-frontend 1.0.928589 → 1.0.929998

package/front_end/core/common/Settings.ts

@@ -41,24 +41,24 @@ import {getLocalizedSettingsCategory, getRegisteredSettings, maybeRemoveSettingE
 let settingsInstance: Settings|undefined;
 
 export class Settings {
-  private readonly sessionStorage: SettingsStorage;
+  readonly #sessionStorage: SettingsStorage;
   settingNameSet: Set<string>;
   orderValuesBySettingCategory: Map<SettingCategory, Set<number>>;
-  private eventSupport: ObjectWrapper<GenericEvents>;
-  private registry: Map<string, Setting<unknown>>;
+  #eventSupport: ObjectWrapper<GenericEvents>;
+  #registry: Map<string, Setting<unknown>>;
   readonly moduleSettings: Map<string, Setting<unknown>>;
 
   private constructor(
       private readonly syncedStorage: SettingsStorage, readonly globalStorage: SettingsStorage,
       private readonly localStorage: SettingsStorage) {
-    this.sessionStorage = new SettingsStorage({});
+    this.#sessionStorage = new SettingsStorage({});
 
     this.settingNameSet = new Set();
 
     this.orderValuesBySettingCategory = new Map();
 
-    this.eventSupport = new ObjectWrapper<GenericEvents>();
-    this.registry = new Map();
+    this.#eventSupport = new ObjectWrapper<GenericEvents>();
+    this.#registry = new Map();
     this.moduleSettings = new Map();
 
     for (const registration of getRegisteredSettings()) {
@@ -139,7 +139,7 @@ export class Settings {
   }
 
   settingForTest(settingName: string): Setting<unknown> {
-    const setting = this.registry.get(settingName);
+    const setting = this.#registry.get(settingName);
     if (!setting) {
       throw new Error('No setting registered: ' + settingName);
     }
@@ -148,10 +148,10 @@ export class Settings {
 
   createSetting<T>(key: string, defaultValue: T, storageType?: SettingStorageType): Setting<T> {
     const storage = this.storageFromType(storageType);
-    let setting = (this.registry.get(key) as Setting<T>);
+    let setting = (this.#registry.get(key) as Setting<T>);
     if (!setting) {
-      setting = new Setting(key, defaultValue, this.eventSupport, storage);
-      this.registry.set(key, setting);
+      setting = new Setting(key, defaultValue, this.#eventSupport, storage);
+      this.#registry.set(key, setting);
     }
     return setting;
   }
@@ -162,11 +162,11 @@ export class Settings {
 
   createRegExpSetting(key: string, defaultValue: string, regexFlags?: string, storageType?: SettingStorageType):
       RegExpSetting {
-    if (!this.registry.get(key)) {
-      this.registry.set(
-          key, new RegExpSetting(key, defaultValue, this.eventSupport, this.storageFromType(storageType), regexFlags));
+    if (!this.#registry.get(key)) {
+      this.#registry.set(
+          key, new RegExpSetting(key, defaultValue, this.#eventSupport, this.storageFromType(storageType), regexFlags));
     }
-    return this.registry.get(key) as RegExpSetting;
+    return this.#registry.get(key) as RegExpSetting;
   }
 
   clearAll(): void {
@@ -178,28 +178,32 @@ export class Settings {
 
   private storageFromType(storageType?: SettingStorageType): SettingsStorage {
     switch (storageType) {
-      case (SettingStorageType.Local):
+      case SettingStorageType.Local:
         return this.localStorage;
-      case (SettingStorageType.Session):
-        return this.sessionStorage;
-      case (SettingStorageType.Global):
+      case SettingStorageType.Session:
+        return this.#sessionStorage;
+      case SettingStorageType.Global:
         return this.globalStorage;
+      case SettingStorageType.Synced:
+        return this.syncedStorage;
     }
     return this.globalStorage;
   }
 
   getRegistry(): Map<string, Setting<unknown>> {
-    return this.registry;
+    return this.#registry;
   }
 }
 
 export interface SettingsBackingStore {
+  register(setting: string): void;
   set(setting: string, value: string): void;
   remove(setting: string): void;
   clear(): void;
 }
 
 export const NOOP_STORAGE: SettingsBackingStore = {
+  register: () => {},
   set: () => {},
   remove: () => {},
   clear: () => {},
@@ -211,6 +215,11 @@ export class SettingsStorage {
       private readonly storagePrefix: string = '') {
   }
 
+  register(name: string): void {
+    name = this.storagePrefix + name;
+    this.backingStore.register(name);
+  }
+
   set(name: string, value: string): void {
     name = this.storagePrefix + name;
     this.object[name] = value;
@@ -273,22 +282,23 @@ function removeSetting(setting: Setting<unknown>): void {
 }
 
 export class Setting<V> {
-  private titleFunction!: () => Platform.UIString.LocalizedString;
-  private titleInternal!: string;
-  private registration: SettingRegistration|null = null;
-  private requiresUserAction?: boolean;
-  private value?: V;
+  #titleFunction?: () => Platform.UIString.LocalizedString;
+  #titleInternal!: string;
+  #registration: SettingRegistration|null = null;
+  #requiresUserAction?: boolean;
+  #value?: V;
   // TODO(crbug.com/1172300) Type cannot be inferred without changes to consumers. See above.
-  private serializer: Serializer<unknown, V> = JSON;
-  private hadUserAction?: boolean;
+  #serializer: Serializer<unknown, V> = JSON;
+  #hadUserAction?: boolean;
 
   constructor(
       readonly name: string, readonly defaultValue: V, private readonly eventSupport: ObjectWrapper<GenericEvents>,
       readonly storage: SettingsStorage) {
+    storage.register(name);
   }
 
   setSerializer(serializer: Serializer<unknown, V>): void {
-    this.serializer = serializer;
+    this.#serializer = serializer;
   }
 
   addChangeListener(listener: (arg0: EventTargetEvent<V>) => void, thisObject?: Object): EventDescriptor {
@@ -300,54 +310,54 @@ export class Setting<V> {
   }
 
   title(): string {
-    if (this.titleInternal) {
-      return this.titleInternal;
+    if (this.#titleInternal) {
+      return this.#titleInternal;
     }
-    if (this.titleFunction) {
-      return this.titleFunction();
+    if (this.#titleFunction) {
+      return this.#titleFunction();
     }
     return '';
   }
 
   setTitleFunction(titleFunction: (() => Platform.UIString.LocalizedString)|undefined): void {
     if (titleFunction) {
-      this.titleFunction = titleFunction;
+      this.#titleFunction = titleFunction;
     }
   }
 
   setTitle(title: string): void {
-    this.titleInternal = title;
+    this.#titleInternal = title;
   }
 
   setRequiresUserAction(requiresUserAction: boolean): void {
-    this.requiresUserAction = requiresUserAction;
+    this.#requiresUserAction = requiresUserAction;
   }
 
   get(): V {
-    if (this.requiresUserAction && !this.hadUserAction) {
+    if (this.#requiresUserAction && !this.#hadUserAction) {
       return this.defaultValue;
     }
 
-    if (typeof this.value !== 'undefined') {
-      return this.value;
+    if (typeof this.#value !== 'undefined') {
+      return this.#value;
     }
 
-    this.value = this.defaultValue;
+    this.#value = this.defaultValue;
     if (this.storage.has(this.name)) {
       try {
-        this.value = this.serializer.parse(this.storage.get(this.name));
+        this.#value = this.#serializer.parse(this.storage.get(this.name));
       } catch (e) {
         this.storage.remove(this.name);
       }
     }
-    return this.value;
+    return this.#value;
   }
 
   set(value: V): void {
-    this.hadUserAction = true;
-    this.value = value;
+    this.#hadUserAction = true;
+    this.#value = value;
     try {
-      const settingString = this.serializer.stringify(value);
+      const settingString = this.#serializer.stringify(value);
       try {
         this.storage.set(this.name, settingString);
       } catch (e) {
@@ -360,19 +370,19 @@ export class Setting<V> {
   }
 
   setRegistration(registration: SettingRegistration): void {
-    this.registration = registration;
+    this.#registration = registration;
   }
 
   type(): SettingType|null {
-    if (this.registration) {
-      return this.registration.settingType;
+    if (this.#registration) {
+      return this.#registration.settingType;
     }
     return null;
   }
 
   options(): SimpleSettingOption[] {
-    if (this.registration && this.registration.options) {
-      return this.registration.options.map(opt => {
+    if (this.#registration && this.#registration.options) {
+      return this.#registration.options.map(opt => {
         const {value, title, text, raw} = opt;
         return {
           value: value,
@@ -386,30 +396,30 @@ export class Setting<V> {
   }
 
   reloadRequired(): boolean|null {
-    if (this.registration) {
-      return this.registration.reloadRequired || null;
+    if (this.#registration) {
+      return this.#registration.reloadRequired || null;
     }
     return null;
   }
 
   category(): SettingCategory|null {
-    if (this.registration) {
-      return this.registration.category || null;
+    if (this.#registration) {
+      return this.#registration.category || null;
     }
     return null;
   }
 
   tags(): string|null {
-    if (this.registration && this.registration.tags) {
+    if (this.#registration && this.#registration.tags) {
       // Get localized keys and separate by null character to prevent fuzzy matching from matching across them.
-      return this.registration.tags.map(tag => tag()).join('\0');
+      return this.#registration.tags.map(tag => tag()).join('\0');
     }
     return null;
   }
 
   order(): number|null {
-    if (this.registration) {
-      return this.registration.order || null;
+    if (this.#registration) {
+      return this.#registration.order || null;
     }
     return null;
   }
@@ -426,14 +436,14 @@ export class Setting<V> {
 // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class RegExpSetting extends Setting<any> {
-  private regexFlags: string|undefined;
-  private regex?: RegExp|null;
+  #regexFlags: string|undefined;
+  #regex?: RegExp|null;
 
   constructor(
       name: string, defaultValue: string, eventSupport: ObjectWrapper<GenericEvents>, storage: SettingsStorage,
       regexFlags?: string) {
     super(name, defaultValue ? [{pattern: defaultValue}] : [], eventSupport, storage);
-    this.regexFlags = regexFlags;
+    this.#regexFlags = regexFlags;
   }
 
   get(): string {
@@ -457,23 +467,23 @@ export class RegExpSetting extends Setting<any> {
   }
 
   setAsArray(value: RegExpSettingItem[]): void {
-    delete this.regex;
+    this.#regex = undefined;
     super.set(value);
   }
 
   asRegExp(): RegExp|null {
-    if (typeof this.regex !== 'undefined') {
-      return this.regex;
+    if (typeof this.#regex !== 'undefined') {
+      return this.#regex;
     }
-    this.regex = null;
+    this.#regex = null;
     try {
       const pattern = this.get();
       if (pattern) {
-        this.regex = new RegExp(pattern, this.regexFlags || '');
+        this.#regex = new RegExp(pattern, this.#regexFlags || '');
       }
     } catch (e) {
     }
-    return this.regex;
+    return this.#regex;
   }
 }
 
@@ -971,7 +981,7 @@ export class VersionController {
     const openTabsInPanel = panelCloseableTabSetting.get();
     const openTabsInDrawer = panelCloseableTabSetting.get();
 
-    // Set value of new setting
+    // Set #value of new setting
     const newValue = Object.assign(openTabsInDrawer, openTabsInPanel);
     closeableTabSetting.set(newValue);
 
@@ -1029,8 +1039,16 @@ export class VersionController {
 // TODO(crbug.com/1167717): Make this a const enum again
 // eslint-disable-next-line rulesdir/const_enum
 export enum SettingStorageType {
+  /**
+   * Synced storage persists settings with the active Chrome profile but also
+   * syncs the settings across devices via Chrome Sync.
+   */
+  Synced = 'Synced',
+  /** Global storage persists settings with the active Chrome profile */
   Global = 'Global',
+  /** Uses Window.localStorage */
   Local = 'Local',
+  /** Session storage dies when DevTools window closes */
   Session = 'Session',
 }
 

package/front_end/core/common/SimpleHistoryManager.ts

@@ -38,27 +38,27 @@ export interface HistoryEntry {
 }
 
 export class SimpleHistoryManager {
-  private entries: HistoryEntry[];
-  private activeEntryIndex: number;
-  private coalescingReadonly: number;
-  private readonly historyDepth: number;
+  #entries: HistoryEntry[];
+  #activeEntryIndex: number;
+  #coalescingReadonly: number;
+  readonly #historyDepth: number;
   constructor(historyDepth: number) {
-    this.entries = [];
-    this.activeEntryIndex = -1;
+    this.#entries = [];
+    this.#activeEntryIndex = -1;
 
     // Lock is used to make sure that reveal() does not
     // make any changes to the history while we are
     // rolling back or rolling over.
-    this.coalescingReadonly = 0;
-    this.historyDepth = historyDepth;
+    this.#coalescingReadonly = 0;
+    this.#historyDepth = historyDepth;
   }
 
   private readOnlyLock(): void {
-    ++this.coalescingReadonly;
+    ++this.#coalescingReadonly;
   }
 
   private releaseReadOnlyLock(): void {
-    --this.coalescingReadonly;
+    --this.#coalescingReadonly;
   }
 
   private getPreviousValidIndex(): number {
@@ -66,8 +66,8 @@ export class SimpleHistoryManager {
       return -1;
     }
 
-    let revealIndex = this.activeEntryIndex - 1;
-    while (revealIndex >= 0 && !this.entries[revealIndex].valid()) {
+    let revealIndex = this.#activeEntryIndex - 1;
+    while (revealIndex >= 0 && !this.#entries[revealIndex].valid()) {
       --revealIndex;
     }
     if (revealIndex < 0) {
@@ -78,12 +78,12 @@ export class SimpleHistoryManager {
   }
 
   private getNextValidIndex(): number {
-    let revealIndex = this.activeEntryIndex + 1;
+    let revealIndex = this.#activeEntryIndex + 1;
 
-    while (revealIndex < this.entries.length && !this.entries[revealIndex].valid()) {
+    while (revealIndex < this.#entries.length && !this.#entries[revealIndex].valid()) {
       ++revealIndex;
     }
-    if (revealIndex >= this.entries.length) {
+    if (revealIndex >= this.#entries.length) {
       return -1;
     }
 
@@ -91,7 +91,7 @@ export class SimpleHistoryManager {
   }
 
   private readOnly(): boolean {
-    return Boolean(this.coalescingReadonly);
+    return Boolean(this.#coalescingReadonly);
   }
 
   filterOut(filterOutCallback: (arg0: HistoryEntry) => boolean): void {
@@ -100,23 +100,23 @@ export class SimpleHistoryManager {
     }
     const filteredEntries = [];
     let removedBeforeActiveEntry = 0;
-    for (let i = 0; i < this.entries.length; ++i) {
-      if (!filterOutCallback(this.entries[i])) {
-        filteredEntries.push(this.entries[i]);
-      } else if (i <= this.activeEntryIndex) {
+    for (let i = 0; i < this.#entries.length; ++i) {
+      if (!filterOutCallback(this.#entries[i])) {
+        filteredEntries.push(this.#entries[i]);
+      } else if (i <= this.#activeEntryIndex) {
         ++removedBeforeActiveEntry;
       }
     }
-    this.entries = filteredEntries;
-    this.activeEntryIndex = Math.max(0, this.activeEntryIndex - removedBeforeActiveEntry);
+    this.#entries = filteredEntries;
+    this.#activeEntryIndex = Math.max(0, this.#activeEntryIndex - removedBeforeActiveEntry);
   }
 
   empty(): boolean {
-    return !this.entries.length;
+    return !this.#entries.length;
   }
 
   active(): HistoryEntry|null {
-    return this.empty() ? null : this.entries[this.activeEntryIndex];
+    return this.empty() ? null : this.#entries[this.#activeEntryIndex];
   }
 
   push(entry: HistoryEntry): void {
@@ -124,13 +124,13 @@ export class SimpleHistoryManager {
       return;
     }
     if (!this.empty()) {
-      this.entries.splice(this.activeEntryIndex + 1);
+      this.#entries.splice(this.#activeEntryIndex + 1);
     }
-    this.entries.push(entry);
-    if (this.entries.length > this.historyDepth) {
-      this.entries.shift();
+    this.#entries.push(entry);
+    if (this.#entries.length > this.#historyDepth) {
+      this.#entries.shift();
     }
-    this.activeEntryIndex = this.entries.length - 1;
+    this.#activeEntryIndex = this.#entries.length - 1;
   }
 
   canRollback(): boolean {
@@ -147,8 +147,8 @@ export class SimpleHistoryManager {
       return false;
     }
     this.readOnlyLock();
-    this.activeEntryIndex = revealIndex;
-    this.entries[revealIndex].reveal();
+    this.#activeEntryIndex = revealIndex;
+    this.#entries[revealIndex].reveal();
     this.releaseReadOnlyLock();
 
     return true;
@@ -161,8 +161,8 @@ export class SimpleHistoryManager {
     }
 
     this.readOnlyLock();
-    this.activeEntryIndex = revealIndex;
-    this.entries[revealIndex].reveal();
+    this.#activeEntryIndex = revealIndex;
+    this.#entries[revealIndex].reveal();
     this.releaseReadOnlyLock();
 
     return true;

package/front_end/core/common/StringOutputStream.ts

@@ -8,19 +8,19 @@ export interface OutputStream {
 }
 
 export class StringOutputStream implements OutputStream {
-  private dataInternal: string;
+  #dataInternal: string;
   constructor() {
-    this.dataInternal = '';
+    this.#dataInternal = '';
   }
 
   async write(chunk: string): Promise<void> {
-    this.dataInternal += chunk;
+    this.#dataInternal += chunk;
   }
 
   async close(): Promise<void> {
   }
 
   data(): string {
-    return this.dataInternal;
+    return this.#dataInternal;
   }
 }

package/front_end/core/common/Throttler.ts

@@ -5,31 +5,31 @@
 export type FinishCallback = (err: Error) => void;
 
 export class Throttler {
-  private readonly timeout: number;
-  private isRunningProcess: boolean;
-  private asSoonAsPossible: boolean;
-  private process: (() => (Promise<unknown>))|null;
-  private lastCompleteTime: number;
-  private schedulePromise: Promise<unknown>;
-  private scheduleResolve!: (value: unknown) => void;
-  private processTimeout?: number;
+  readonly #timeout: number;
+  #isRunningProcess: boolean;
+  #asSoonAsPossible: boolean;
+  #process: (() => (Promise<unknown>))|null;
+  #lastCompleteTime: number;
+  #schedulePromise: Promise<unknown>;
+  #scheduleResolve!: (value: unknown) => void;
+  #processTimeout?: number;
 
   constructor(timeout: number) {
-    this.timeout = timeout;
-    this.isRunningProcess = false;
-    this.asSoonAsPossible = false;
-    this.process = null;
-    this.lastCompleteTime = 0;
-
-    this.schedulePromise = new Promise(fulfill => {
-      this.scheduleResolve = fulfill;
+    this.#timeout = timeout;
+    this.#isRunningProcess = false;
+    this.#asSoonAsPossible = false;
+    this.#process = null;
+    this.#lastCompleteTime = 0;
+
+    this.#schedulePromise = new Promise(fulfill => {
+      this.#scheduleResolve = fulfill;
     });
   }
 
   private processCompleted(): void {
-    this.lastCompleteTime = this.getTime();
-    this.isRunningProcess = false;
-    if (this.process) {
+    this.#lastCompleteTime = this.getTime();
+    this.#isRunningProcess = false;
+    if (this.#process) {
       this.innerSchedule(false);
     }
     this.processCompletedForTests();
@@ -39,52 +39,56 @@ export class Throttler {
     // For sniffing in tests.
   }
 
+  get process(): (() => (Promise<unknown>))|null {
+    return this.#process;
+  }
+
   private onTimeout(): void {
-    delete this.processTimeout;
-    this.asSoonAsPossible = false;
-    this.isRunningProcess = true;
+    this.#processTimeout = undefined;
+    this.#asSoonAsPossible = false;
+    this.#isRunningProcess = true;
 
     Promise.resolve()
-        .then(this.process)
+        .then(this.#process)
         .catch(console.error.bind(console))
         .then(this.processCompleted.bind(this))
-        .then(this.scheduleResolve);
-    this.schedulePromise = new Promise(fulfill => {
-      this.scheduleResolve = fulfill;
+        .then(this.#scheduleResolve);
+    this.#schedulePromise = new Promise(fulfill => {
+      this.#scheduleResolve = fulfill;
     });
-    this.process = null;
+    this.#process = null;
   }
 
   schedule(process: () => (Promise<unknown>), asSoonAsPossible?: boolean): Promise<void> {
-    // Deliberately skip previous process.
-    this.process = process;
+    // Deliberately skip previous #process.
+    this.#process = process;
 
     // Run the first scheduled task instantly.
-    const hasScheduledTasks = Boolean(this.processTimeout) || this.isRunningProcess;
-    const okToFire = this.getTime() - this.lastCompleteTime > this.timeout;
+    const hasScheduledTasks = Boolean(this.#processTimeout) || this.#isRunningProcess;
+    const okToFire = this.getTime() - this.#lastCompleteTime > this.#timeout;
     asSoonAsPossible = Boolean(asSoonAsPossible) || (!hasScheduledTasks && okToFire);
 
-    const forceTimerUpdate = asSoonAsPossible && !this.asSoonAsPossible;
-    this.asSoonAsPossible = this.asSoonAsPossible || asSoonAsPossible;
+    const forceTimerUpdate = asSoonAsPossible && !this.#asSoonAsPossible;
+    this.#asSoonAsPossible = this.#asSoonAsPossible || asSoonAsPossible;
 
     this.innerSchedule(forceTimerUpdate);
 
-    return this.schedulePromise as Promise<void>;
+    return this.#schedulePromise as Promise<void>;
   }
 
   private innerSchedule(forceTimerUpdate: boolean): void {
-    if (this.isRunningProcess) {
+    if (this.#isRunningProcess) {
       return;
     }
-    if (this.processTimeout && !forceTimerUpdate) {
+    if (this.#processTimeout && !forceTimerUpdate) {
       return;
     }
-    if (this.processTimeout) {
-      this.clearTimeout(this.processTimeout);
+    if (this.#processTimeout) {
+      this.clearTimeout(this.#processTimeout);
     }
 
-    const timeout = this.asSoonAsPossible ? 0 : this.timeout;
-    this.processTimeout = this.setTimeout(this.onTimeout.bind(this), timeout);
+    const timeout = this.#asSoonAsPossible ? 0 : this.#timeout;
+    this.#processTimeout = this.setTimeout(this.onTimeout.bind(this), timeout);
   }
 
   private clearTimeout(timeoutId: number): void {