chrome-devtools-frontend 1.0.951864 → 1.0.952784

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

@@ -7,26 +7,26 @@ 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);
-    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.targetManager = targetManager;
-    this.context = context;
+        this.#onExecutionContextOrderChanged, this);
+    this.#targetManager = targetManager;
+    this.#context = context;
     targetManager.observeModels(SDK.RuntimeModel.RuntimeModel, this);
   }
 
@@ -37,41 +37,41 @@ 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();
+      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());
     }
   }
 
-  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.#context.setFlavor(SDK.Target.Target, newContext.target());
+      if (!this.#ignoreContextChanged) {
+        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 {
-    const currentContext = this.context.flavor(SDK.RuntimeModel.ExecutionContext);
+  #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)) {
       return;
@@ -85,28 +85,28 @@ 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];
       }
     }
-    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)) {
+  #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,47 +118,44 @@ 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();
+    if (this.#context.flavor(SDK.RuntimeModel.ExecutionContext) === executionContext) {
+      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)) {
-      this.ignoreContextChanged = true;
-      this.context.setFlavor(SDK.RuntimeModel.ExecutionContext, executionContext);
-      this.ignoreContextChanged = false;
+  #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;
       return true;
     }
     return false;
   }
 
-  private currentExecutionContextGone(): void {
-    const runtimeModels = this.targetManager.models(SDK.RuntimeModel.RuntimeModel);
+  #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;
         }
@@ -173,8 +170,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;
   }
 }

package/front_end/entrypoints/main/MainImpl.ts

@@ -114,11 +114,11 @@ const str_ = i18n.i18n.registerUIStrings('entrypoints/main/MainImpl.ts', UIStrin
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class MainImpl {
-  private lateInitDonePromise!: Promise<void>;
+  #lateInitDonePromise!: Promise<void>;
 
   constructor() {
     MainImpl.instanceForTest = this;
-    this.loaded();
+    this.#loaded();
   }
 
   static time(label: string): void {
@@ -135,7 +135,7 @@ export class MainImpl {
     console.timeEnd(label);
   }
 
-  private async loaded(): Promise<void> {
+  async #loaded(): Promise<void> {
     console.timeStamp('Main._loaded');
     Root.Runtime.Runtime.setPlatform(Host.Platform.platform());
     const prefs = await new Promise<{[key: string]: string}>(resolve => {
@@ -143,7 +143,7 @@ export class MainImpl {
     });
 
     console.timeStamp('Main._gotPreferences');
-    this.initializeGlobalsForLayoutTests();
+    this.#initializeGlobalsForLayoutTests();
     this.createSettings(prefs);
     await this.requestAndRegisterLocaleData();
 
@@ -152,10 +152,10 @@ export class MainImpl {
           Common.Settings.Settings.instance().moduleSetting<boolean>('sync_preferences').get());
     }
 
-    this.createAppUI();
+    this.#createAppUI();
   }
 
-  private initializeGlobalsForLayoutTests(): void {
+  #initializeGlobalsForLayoutTests(): void {
     // @ts-ignore layout test global
     self.Common = self.Common || {};
     // @ts-ignore layout test global
@@ -209,10 +209,10 @@ export class MainImpl {
     }
   }
 
-  private createSettings(prefs: {
+  createSettings(prefs: {
     [x: string]: string,
   }): void {
-    this.initializeExperiments();
+    this.#initializeExperiments();
     let storagePrefix = '';
     if (Host.Platform.isCustomDevtoolsFrontend()) {
       storagePrefix = '__custom__';
@@ -260,7 +260,7 @@ export class MainImpl {
     }
   }
 
-  private initializeExperiments(): void {
+  #initializeExperiments(): void {
     Root.Runtime.experiments.register('applyCustomStylesheet', 'Allow extensions to load custom stylesheets');
     Root.Runtime.experiments.register('captureNodeCreationStacks', 'Capture node creation stacks');
     Root.Runtime.experiments.register('sourcesPrettyPrint', 'Automatically pretty print in the Sources Panel');
@@ -395,7 +395,7 @@ export class MainImpl {
       Host.userMetrics.experimentEnabledAtLaunch(experiment.name);
     }
   }
-  private async createAppUI(): Promise<void> {
+  async #createAppUI(): Promise<void> {
     MainImpl.time('Main._createAppUI');
 
     // @ts-ignore layout test global
@@ -418,7 +418,7 @@ export class MainImpl {
     }
     UI.UIUtils.installComponentRootStyles((document.body as Element));
 
-    this.addMainEventListeners(document);
+    this.#addMainEventListeners(document);
 
     const canDock = Boolean(Root.Runtime.Runtime.queryParam('can_dock'));
     // @ts-ignore layout test global
@@ -450,7 +450,7 @@ export class MainImpl {
     // @ts-ignore layout test global
     self.SDK.domDebuggerManager = SDK.DOMDebuggerModel.DOMDebuggerManager.instance({forceNew: true});
     SDK.TargetManager.TargetManager.instance().addEventListener(
-        SDK.TargetManager.Events.SuspendStateChanged, this.onSuspendStateChanged.bind(this));
+        SDK.TargetManager.Events.SuspendStateChanged, this.#onSuspendStateChanged.bind(this));
 
     // @ts-ignore layout test global
     self.Workspace.fileManager = Workspace.FileManager.FileManager.instance({forceNew: true});
@@ -522,7 +522,7 @@ export class MainImpl {
     // @ts-ignore layout test global
     self.UI.shortcutRegistry =
         UI.ShortcutRegistry.ShortcutRegistry.instance({forceNew: true, actionRegistry: actionRegistryInstance});
-    this.registerMessageSinkListener();
+    this.#registerMessageSinkListener();
 
     MainImpl.timeEnd('Main._createAppUI');
 
@@ -530,10 +530,10 @@ export class MainImpl {
     if (!appProvider) {
       throw new Error('Unable to boot DevTools, as the appprovider is missing');
     }
-    await this.showAppUI(await appProvider.loadAppProvider());
+    await this.#showAppUI(await appProvider.loadAppProvider());
   }
 
-  private async showAppUI(appProvider: Object): Promise<void> {
+  async #showAppUI(appProvider: Object): Promise<void> {
     MainImpl.time('Main._showAppUI');
     const app = (appProvider as Common.AppProvider.AppProvider).createApp();
     // It is important to kick controller lifetime after apps are instantiated.
@@ -549,7 +549,7 @@ export class MainImpl {
           }, this);
     }
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
-        Host.InspectorFrontendHostAPI.Events.RevealSourceLine, this.revealSourceLine, this);
+        Host.InspectorFrontendHostAPI.Events.RevealSourceLine, this.#revealSourceLine, this);
 
     await UI.InspectorView.InspectorView.instance().createToolbars();
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.loadCompleted();
@@ -563,11 +563,11 @@ export class MainImpl {
     UI.ARIAUtils.alertElementInstance();
 
     // Allow UI cycles to repaint prior to creating connection.
-    setTimeout(this.initializeTarget.bind(this), 0);
+    setTimeout(this.#initializeTarget.bind(this), 0);
     MainImpl.timeEnd('Main._showAppUI');
   }
 
-  private async initializeTarget(): Promise<void> {
+  async #initializeTarget(): Promise<void> {
     MainImpl.time('Main._initializeTarget');
 
     // We rely on having the early initialization runnables registered in Common when an app loads its
@@ -579,11 +579,11 @@ export class MainImpl {
     // Used for browser tests.
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.readyForTest();
     // Asynchronously run the extensions.
-    setTimeout(this.lateInitialization.bind(this), 100);
+    setTimeout(this.#lateInitialization.bind(this), 100);
     MainImpl.timeEnd('Main._initializeTarget');
   }
 
-  private lateInitialization(): void {
+  #lateInitialization(): void {
     MainImpl.time('Main._lateInitialization');
     Extensions.ExtensionServer.ExtensionServer.instance().initializeExtensions();
     const promises: Promise<void>[] =
@@ -606,15 +606,15 @@ export class MainImpl {
         Common.Settings.Settings.instance().moduleSetting(setting).addChangeListener(changeListener);
       }
     }
-    this.lateInitDonePromise = Promise.all(promises).then(() => undefined);
+    this.#lateInitDonePromise = Promise.all(promises).then(() => undefined);
     MainImpl.timeEnd('Main._lateInitialization');
   }
 
   lateInitDonePromiseForTest(): Promise<void>|null {
-    return this.lateInitDonePromise;
+    return this.#lateInitDonePromise;
   }
 
-  private registerMessageSinkListener(): void {
+  #registerMessageSinkListener(): void {
     Common.Console.Console.instance().addEventListener(Common.Console.Events.MessageAdded, messageAdded);
 
     function messageAdded({data: message}: Common.EventTarget.EventTargetEvent<Common.Console.Message>): void {
@@ -624,8 +624,8 @@ export class MainImpl {
     }
   }
 
-  private revealSourceLine(
-      event: Common.EventTarget.EventTargetEvent<Host.InspectorFrontendHostAPI.RevealSourceLineEvent>): void {
+  #revealSourceLine(event: Common.EventTarget.EventTargetEvent<Host.InspectorFrontendHostAPI.RevealSourceLineEvent>):
+      void {
     const {url, lineNumber, columnNumber} = event.data;
     const uiSourceCode = Workspace.Workspace.WorkspaceImpl.instance().uiSourceCodeForURL(url);
     if (uiSourceCode) {
@@ -646,13 +646,13 @@ export class MainImpl {
         Workspace.Workspace.Events.UISourceCodeAdded, listener);
   }
 
-  private postDocumentKeyDown(event: Event): void {
+  #postDocumentKeyDown(event: Event): void {
     if (!event.handled) {
       UI.ShortcutRegistry.ShortcutRegistry.instance().handleShortcut((event as KeyboardEvent));
     }
   }
 
-  private redispatchClipboardEvent(event: Event): void {
+  #redispatchClipboardEvent(event: Event): void {
     const eventCopy = new CustomEvent('clipboard-' + event.type, {bubbles: true});
     // @ts-ignore Used in ElementsTreeOutline
     eventCopy['original'] = event;
@@ -666,22 +666,22 @@ export class MainImpl {
     }
   }
 
-  private contextMenuEventFired(event: Event): void {
+  #contextMenuEventFired(event: Event): void {
     if (event.handled || (event.target as HTMLElement).classList.contains('popup-glasspane')) {
       event.preventDefault();
     }
   }
 
-  private addMainEventListeners(document: Document): void {
-    document.addEventListener('keydown', this.postDocumentKeyDown.bind(this), false);
-    document.addEventListener('beforecopy', this.redispatchClipboardEvent.bind(this), true);
-    document.addEventListener('copy', this.redispatchClipboardEvent.bind(this), false);
-    document.addEventListener('cut', this.redispatchClipboardEvent.bind(this), false);
-    document.addEventListener('paste', this.redispatchClipboardEvent.bind(this), false);
-    document.addEventListener('contextmenu', this.contextMenuEventFired.bind(this), true);
+  #addMainEventListeners(document: Document): void {
+    document.addEventListener('keydown', this.#postDocumentKeyDown.bind(this), false);
+    document.addEventListener('beforecopy', this.#redispatchClipboardEvent.bind(this), true);
+    document.addEventListener('copy', this.#redispatchClipboardEvent.bind(this), false);
+    document.addEventListener('cut', this.#redispatchClipboardEvent.bind(this), false);
+    document.addEventListener('paste', this.#redispatchClipboardEvent.bind(this), false);
+    document.addEventListener('contextmenu', this.#contextMenuEventFired.bind(this), true);
   }
 
-  private onSuspendStateChanged(): void {
+  #onSuspendStateChanged(): void {
     const suspended = SDK.TargetManager.TargetManager.instance().allTargetsSuspended();
     UI.InspectorView.InspectorView.instance().onSuspendStateChanged(suspended);
   }
@@ -769,11 +769,11 @@ export class SearchActionDelegate implements UI.ActionRegistration.ActionDelegat
 let mainMenuItemInstance: MainMenuItem;
 
 export class MainMenuItem implements UI.Toolbar.Provider {
-  private readonly itemInternal: UI.Toolbar.ToolbarMenuButton;
+  readonly #itemInternal: UI.Toolbar.ToolbarMenuButton;
   constructor() {
-    this.itemInternal = new UI.Toolbar.ToolbarMenuButton(this.handleContextMenu.bind(this), true);
-    this.itemInternal.element.classList.add('main-menu');
-    this.itemInternal.setTitle(i18nString(UIStrings.customizeAndControlDevtools));
+    this.#itemInternal = new UI.Toolbar.ToolbarMenuButton(this.#handleContextMenu.bind(this), true);
+    this.#itemInternal.element.classList.add('main-menu');
+    this.#itemInternal.setTitle(i18nString(UIStrings.customizeAndControlDevtools));
   }
 
   static instance(opts: {
@@ -788,10 +788,10 @@ export class MainMenuItem implements UI.Toolbar.Provider {
   }
 
   item(): UI.Toolbar.ToolbarItem|null {
-    return this.itemInternal;
+    return this.#itemInternal;
   }
 
-  private handleContextMenu(contextMenu: UI.ContextMenu.ContextMenu): void {
+  #handleContextMenu(contextMenu: UI.ContextMenu.ContextMenu): void {
     if (UI.DockController.DockController.instance().canDock()) {
       const dockItemElement = document.createElement('div');
       dockItemElement.classList.add('flex-centered');
@@ -853,7 +853,7 @@ export class MainMenuItem implements UI.Toolbar.Provider {
       contextMenu.headerSection().appendCustomItem(dockItemElement);
     }
 
-    const button = (this.itemInternal.element as HTMLButtonElement);
+    const button = (this.#itemInternal.element as HTMLButtonElement);
 
     function setDockSide(side: UI.DockController.DockState): void {
       UI.DockController.DockController.instance().once(UI.DockController.Events.AfterDockSideChanged).then(() => {
@@ -926,10 +926,10 @@ export class MainMenuItem implements UI.Toolbar.Provider {
 let settingsButtonProviderInstance: SettingsButtonProvider;
 
 export class SettingsButtonProvider implements UI.Toolbar.Provider {
-  private readonly settingsButton: UI.Toolbar.ToolbarButton;
+  readonly #settingsButton: UI.Toolbar.ToolbarButton;
   private constructor() {
     const settingsActionId = 'settings.show';
-    this.settingsButton =
+    this.#settingsButton =
         UI.Toolbar.Toolbar.createActionButtonForId(settingsActionId, {showLabel: false, userActionCode: undefined});
   }
 
@@ -945,19 +945,19 @@ export class SettingsButtonProvider implements UI.Toolbar.Provider {
   }
 
   item(): UI.Toolbar.ToolbarItem|null {
-    return this.settingsButton;
+    return this.#settingsButton;
   }
 }
 
 export class PauseListener {
   constructor() {
     SDK.TargetManager.TargetManager.instance().addModelListener(
-        SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.DebuggerPaused, this.debuggerPaused, this);
+        SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.DebuggerPaused, this.#debuggerPaused, this);
   }
 
-  private debuggerPaused(event: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.DebuggerModel>): void {
+  #debuggerPaused(event: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.DebuggerModel>): void {
     SDK.TargetManager.TargetManager.instance().removeModelListener(
-        SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.DebuggerPaused, this.debuggerPaused, this);
+        SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.DebuggerPaused, this.#debuggerPaused, this);
     const debuggerModel = event.data;
     const debuggerPausedDetails = debuggerModel.debuggerPausedDetails();
     UI.Context.Context.instance().setFlavor(SDK.Target.Target, debuggerModel.target());