chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/EmulationModel.ts

@@ -14,29 +14,29 @@ import {Capability} from './Target.js';
 import {SDKModel} from './SDKModel.js';
 
 export class EmulationModel extends SDKModel<void> {
-  private readonly emulationAgent: ProtocolProxyApi.EmulationApi;
-  private readonly pageAgent: ProtocolProxyApi.PageApi;
-  private readonly deviceOrientationAgent: ProtocolProxyApi.DeviceOrientationApi;
-  private cssModel: CSSModel|null;
-  private readonly overlayModelInternal: OverlayModel|null;
-  private readonly mediaConfiguration: Map<string, string>;
-  private touchEnabled: boolean;
-  private touchMobile: boolean;
-  private customTouchEnabled: boolean;
-  private touchConfiguration: {
+  readonly #emulationAgent: ProtocolProxyApi.EmulationApi;
+  readonly #pageAgent: ProtocolProxyApi.PageApi;
+  readonly #deviceOrientationAgent: ProtocolProxyApi.DeviceOrientationApi;
+  #cssModel: CSSModel|null;
+  readonly #overlayModelInternal: OverlayModel|null;
+  readonly #mediaConfiguration: Map<string, string>;
+  #touchEnabled: boolean;
+  #touchMobile: boolean;
+  #customTouchEnabled: boolean;
+  #touchConfiguration: {
     enabled: boolean,
     configuration: Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration,
   };
 
   constructor(target: Target) {
     super(target);
-    this.emulationAgent = target.emulationAgent();
-    this.pageAgent = target.pageAgent();
-    this.deviceOrientationAgent = target.deviceOrientationAgent();
-    this.cssModel = target.model(CSSModel);
-    this.overlayModelInternal = target.model(OverlayModel);
-    if (this.overlayModelInternal) {
-      this.overlayModelInternal.addEventListener(Events.InspectModeWillBeToggled, () => {
+    this.#emulationAgent = target.emulationAgent();
+    this.#pageAgent = target.pageAgent();
+    this.#deviceOrientationAgent = target.deviceOrientationAgent();
+    this.#cssModel = target.model(CSSModel);
+    this.#overlayModelInternal = target.model(OverlayModel);
+    if (this.#overlayModelInternal) {
+      this.#overlayModelInternal.addEventListener(Events.InspectModeWillBeToggled, () => {
         this.updateTouch();
       }, this);
     }
@@ -44,9 +44,9 @@ export class EmulationModel extends SDKModel<void> {
     const disableJavascriptSetting = Common.Settings.Settings.instance().moduleSetting('javaScriptDisabled');
     disableJavascriptSetting.addChangeListener(
         async () =>
-            await this.emulationAgent.invoke_setScriptExecutionDisabled({value: disableJavascriptSetting.get()}));
+            await this.#emulationAgent.invoke_setScriptExecutionDisabled({value: disableJavascriptSetting.get()}));
     if (disableJavascriptSetting.get()) {
-      this.emulationAgent.invoke_setScriptExecutionDisabled({value: true});
+      this.#emulationAgent.invoke_setScriptExecutionDisabled({value: true});
     }
 
     const touchSetting = Common.Settings.Settings.instance().moduleSetting('emulation.touch');
@@ -86,7 +86,7 @@ export class EmulationModel extends SDKModel<void> {
     // because we want to update these values per media type/feature
     // without having to search the `features` array (inefficient) or
     // hardcoding the indices (not readable/maintainable).
-    this.mediaConfiguration = new Map([
+    this.#mediaConfiguration = new Map([
       ['type', mediaTypeSetting.get()],
       ['color-gamut', mediaFeatureColorGamutSetting.get()],
       ['prefers-color-scheme', mediaFeaturePrefersColorSchemeSetting.get()],
@@ -95,27 +95,27 @@ export class EmulationModel extends SDKModel<void> {
       ['prefers-reduced-motion', mediaFeaturePrefersReducedMotionSetting.get()],
     ]);
     mediaTypeSetting.addChangeListener(() => {
-      this.mediaConfiguration.set('type', mediaTypeSetting.get());
+      this.#mediaConfiguration.set('type', mediaTypeSetting.get());
       this.updateCssMedia();
     });
     mediaFeatureColorGamutSetting.addChangeListener(() => {
-      this.mediaConfiguration.set('color-gamut', mediaFeatureColorGamutSetting.get());
+      this.#mediaConfiguration.set('color-gamut', mediaFeatureColorGamutSetting.get());
       this.updateCssMedia();
     });
     mediaFeaturePrefersColorSchemeSetting.addChangeListener(() => {
-      this.mediaConfiguration.set('prefers-color-scheme', mediaFeaturePrefersColorSchemeSetting.get());
+      this.#mediaConfiguration.set('prefers-color-scheme', mediaFeaturePrefersColorSchemeSetting.get());
       this.updateCssMedia();
     });
     mediaFeaturePrefersContrastSetting.addChangeListener(() => {
-      this.mediaConfiguration.set('prefers-contrast', mediaFeaturePrefersContrastSetting.get());
+      this.#mediaConfiguration.set('prefers-contrast', mediaFeaturePrefersContrastSetting.get());
       this.updateCssMedia();
     });
     mediaFeaturePrefersReducedDataSetting.addChangeListener(() => {
-      this.mediaConfiguration.set('prefers-reduced-data', mediaFeaturePrefersReducedDataSetting.get());
+      this.#mediaConfiguration.set('prefers-reduced-data', mediaFeaturePrefersReducedDataSetting.get());
       this.updateCssMedia();
     });
     mediaFeaturePrefersReducedMotionSetting.addChangeListener(() => {
-      this.mediaConfiguration.set('prefers-reduced-motion', mediaFeaturePrefersReducedMotionSetting.get());
+      this.#mediaConfiguration.set('prefers-reduced-motion', mediaFeaturePrefersReducedMotionSetting.get());
       this.updateCssMedia();
     });
     this.updateCssMedia();
@@ -164,10 +164,10 @@ export class EmulationModel extends SDKModel<void> {
       updateDisabledImageFormats();
     }
 
-    this.touchEnabled = false;
-    this.touchMobile = false;
-    this.customTouchEnabled = false;
-    this.touchConfiguration = {
+    this.#touchEnabled = false;
+    this.#touchMobile = false;
+    this.#customTouchEnabled = false;
+    this.#touchConfiguration = {
       enabled: false,
       configuration: Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Mobile,
     };
@@ -178,28 +178,28 @@ export class EmulationModel extends SDKModel<void> {
   }
 
   async resetPageScaleFactor(): Promise<void> {
-    await this.emulationAgent.invoke_resetPageScaleFactor();
+    await this.#emulationAgent.invoke_resetPageScaleFactor();
   }
 
   async emulateDevice(metrics: Protocol.Page.SetDeviceMetricsOverrideRequest|null): Promise<void> {
     if (metrics) {
-      await this.emulationAgent.invoke_setDeviceMetricsOverride(metrics);
+      await this.#emulationAgent.invoke_setDeviceMetricsOverride(metrics);
     } else {
-      await this.emulationAgent.invoke_clearDeviceMetricsOverride();
+      await this.#emulationAgent.invoke_clearDeviceMetricsOverride();
     }
   }
 
   overlayModel(): OverlayModel|null {
-    return this.overlayModelInternal;
+    return this.#overlayModelInternal;
   }
 
   async emulateLocation(location: Location|null): Promise<void> {
     if (!location || location.error) {
       await Promise.all([
-        this.emulationAgent.invoke_clearGeolocationOverride(),
-        this.emulationAgent.invoke_setTimezoneOverride({timezoneId: ''}),
-        this.emulationAgent.invoke_setLocaleOverride({locale: ''}),
-        this.emulationAgent.invoke_setUserAgentOverride(
+        this.#emulationAgent.invoke_clearGeolocationOverride(),
+        this.#emulationAgent.invoke_setTimezoneOverride({timezoneId: ''}),
+        this.#emulationAgent.invoke_setLocaleOverride({locale: ''}),
+        this.#emulationAgent.invoke_setUserAgentOverride(
             {userAgent: MultitargetNetworkManager.instance().currentUserAgent()}),
       ]);
     } else {
@@ -215,24 +215,24 @@ export class EmulationModel extends SDKModel<void> {
       }
 
       await Promise.all([
-        this.emulationAgent
+        this.#emulationAgent
             .invoke_setGeolocationOverride({
               latitude: location.latitude,
               longitude: location.longitude,
               accuracy: Location.defaultGeoMockAccuracy,
             })
             .then(result => processEmulationResult('emulation-set-location', result)),
-        this.emulationAgent
+        this.#emulationAgent
             .invoke_setTimezoneOverride({
               timezoneId: location.timezoneId,
             })
             .then(result => processEmulationResult('emulation-set-timezone', result)),
-        this.emulationAgent
+        this.#emulationAgent
             .invoke_setLocaleOverride({
               locale: location.locale,
             })
             .then(result => processEmulationResult('emulation-set-locale', result)),
-        this.emulationAgent
+        this.#emulationAgent
             .invoke_setUserAgentOverride({
               userAgent: MultitargetNetworkManager.instance().currentUserAgent(),
               acceptLanguage: location.locale,
@@ -244,10 +244,10 @@ export class EmulationModel extends SDKModel<void> {
 
   async emulateDeviceOrientation(deviceOrientation: DeviceOrientation|null): Promise<void> {
     if (deviceOrientation) {
-      await this.deviceOrientationAgent.invoke_setDeviceOrientationOverride(
+      await this.#deviceOrientationAgent.invoke_setDeviceOrientationOverride(
           {alpha: deviceOrientation.alpha, beta: deviceOrientation.beta, gamma: deviceOrientation.gamma});
     } else {
-      await this.deviceOrientationAgent.invoke_clearDeviceOrientationOverride();
+      await this.#deviceOrientationAgent.invoke_clearDeviceOrientationOverride();
     }
   }
 
@@ -255,20 +255,20 @@ export class EmulationModel extends SDKModel<void> {
     isUserActive: boolean,
     isScreenUnlocked: boolean,
   }): Promise<void> {
-    await this.emulationAgent.invoke_setIdleOverride(emulationParams);
+    await this.#emulationAgent.invoke_setIdleOverride(emulationParams);
   }
 
   async clearIdleOverride(): Promise<void> {
-    await this.emulationAgent.invoke_clearIdleOverride();
+    await this.#emulationAgent.invoke_clearIdleOverride();
   }
 
   private async emulateCSSMedia(type: string, features: {
     name: string,
     value: string,
   }[]): Promise<void> {
-    await this.emulationAgent.invoke_setEmulatedMedia({media: type, features});
-    if (this.cssModel) {
-      this.cssModel.mediaQueryResultChanged();
+    await this.#emulationAgent.invoke_setEmulatedMedia({media: type, features});
+    if (this.#cssModel) {
+      this.#cssModel.mediaQueryResultChanged();
     }
   }
 
@@ -287,97 +287,97 @@ export class EmulationModel extends SDKModel<void> {
 
   private async emulateAutoDarkMode(setting: string): Promise<void> {
     const enabled = EmulationModel.parseAutoDarkModeSetting(setting);
-    await this.emulationAgent.invoke_setAutoDarkModeOverride({enabled});
+    await this.#emulationAgent.invoke_setAutoDarkModeOverride({enabled});
   }
 
   private async emulateVisionDeficiency(type: Protocol.Emulation.SetEmulatedVisionDeficiencyRequestType):
       Promise<void> {
-    await this.emulationAgent.invoke_setEmulatedVisionDeficiency({type});
+    await this.#emulationAgent.invoke_setEmulatedVisionDeficiency({type});
   }
 
   private setLocalFontsDisabled(disabled: boolean): void {
-    if (!this.cssModel) {
+    if (!this.#cssModel) {
       return;
     }
-    this.cssModel.setLocalFontsEnabled(!disabled);
+    this.#cssModel.setLocalFontsEnabled(!disabled);
   }
 
   private setDisabledImageTypes(imageTypes: Protocol.Emulation.DisabledImageType[]): void {
-    this.emulationAgent.invoke_setDisabledImageTypes({imageTypes});
+    this.#emulationAgent.invoke_setDisabledImageTypes({imageTypes});
   }
 
   async setCPUThrottlingRate(rate: number): Promise<void> {
-    await this.emulationAgent.invoke_setCPUThrottlingRate({rate});
+    await this.#emulationAgent.invoke_setCPUThrottlingRate({rate});
   }
 
   async emulateTouch(enabled: boolean, mobile: boolean): Promise<void> {
-    this.touchEnabled = enabled;
-    this.touchMobile = mobile;
+    this.#touchEnabled = enabled;
+    this.#touchMobile = mobile;
     await this.updateTouch();
   }
 
   async overrideEmulateTouch(enabled: boolean): Promise<void> {
-    this.customTouchEnabled = enabled;
+    this.#customTouchEnabled = enabled;
     await this.updateTouch();
   }
 
   private async updateTouch(): Promise<void> {
     let configuration = {
-      enabled: this.touchEnabled,
-      configuration: this.touchMobile ? Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Mobile :
-                                        Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Desktop,
+      enabled: this.#touchEnabled,
+      configuration: this.#touchMobile ? Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Mobile :
+                                         Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Desktop,
     };
-    if (this.customTouchEnabled) {
+    if (this.#customTouchEnabled) {
       configuration = {
         enabled: true,
         configuration: Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Mobile,
       };
     }
 
-    if (this.overlayModelInternal && this.overlayModelInternal.inspectModeEnabled()) {
+    if (this.#overlayModelInternal && this.#overlayModelInternal.inspectModeEnabled()) {
       configuration = {
         enabled: false,
         configuration: Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Mobile,
       };
     }
 
-    if (!this.touchConfiguration.enabled && !configuration.enabled) {
+    if (!this.#touchConfiguration.enabled && !configuration.enabled) {
       return;
     }
-    if (this.touchConfiguration.enabled && configuration.enabled &&
-        this.touchConfiguration.configuration === configuration.configuration) {
+    if (this.#touchConfiguration.enabled && configuration.enabled &&
+        this.#touchConfiguration.configuration === configuration.configuration) {
       return;
     }
 
-    this.touchConfiguration = configuration;
-    await this.emulationAgent.invoke_setTouchEmulationEnabled({enabled: configuration.enabled, maxTouchPoints: 1});
-    await this.emulationAgent.invoke_setEmitTouchEventsForMouse(
+    this.#touchConfiguration = configuration;
+    await this.#emulationAgent.invoke_setTouchEmulationEnabled({enabled: configuration.enabled, maxTouchPoints: 1});
+    await this.#emulationAgent.invoke_setEmitTouchEventsForMouse(
         {enabled: configuration.enabled, configuration: configuration.configuration});
   }
 
   private updateCssMedia(): void {
-    // See the note above, where this.mediaConfiguration is defined.
-    const type = this.mediaConfiguration.get('type') ?? '';
+    // See the note above, where this.#mediaConfiguration is defined.
+    const type = this.#mediaConfiguration.get('type') ?? '';
     const features = [
       {
         name: 'color-gamut',
-        value: this.mediaConfiguration.get('color-gamut') ?? '',
+        value: this.#mediaConfiguration.get('color-gamut') ?? '',
       },
       {
         name: 'prefers-color-scheme',
-        value: this.mediaConfiguration.get('prefers-color-scheme') ?? '',
+        value: this.#mediaConfiguration.get('prefers-color-scheme') ?? '',
       },
       {
         name: 'prefers-contrast',
-        value: this.mediaConfiguration.get('prefers-contrast') ?? '',
+        value: this.#mediaConfiguration.get('prefers-contrast') ?? '',
       },
       {
         name: 'prefers-reduced-data',
-        value: this.mediaConfiguration.get('prefers-reduced-data') ?? '',
+        value: this.#mediaConfiguration.get('prefers-reduced-data') ?? '',
       },
       {
         name: 'prefers-reduced-motion',
-        value: this.mediaConfiguration.get('prefers-reduced-motion') ?? '',
+        value: this.#mediaConfiguration.get('prefers-reduced-motion') ?? '',
       },
     ];
     this.emulateCSSMedia(type, features);

package/front_end/core/sdk/FilmStripModel.ts

@@ -8,22 +8,22 @@ import type {Event, ObjectSnapshot} from './TracingModel.js';
 import {TracingModel} from './TracingModel.js';
 
 export class FilmStripModel {
-  private framesInternal: Frame[];
-  private zeroTimeInternal: number;
-  private spanTimeInternal: number;
+  #framesInternal: Frame[];
+  #zeroTimeInternal: number;
+  #spanTimeInternal: number;
   constructor(tracingModel: TracingModel, zeroTime?: number) {
-    this.framesInternal = [];
-    this.zeroTimeInternal = 0;
-    this.spanTimeInternal = 0;
+    this.#framesInternal = [];
+    this.#zeroTimeInternal = 0;
+    this.#spanTimeInternal = 0;
 
     this.reset(tracingModel, zeroTime);
   }
 
   reset(tracingModel: TracingModel, zeroTime?: number): void {
-    this.zeroTimeInternal = zeroTime || tracingModel.minimumRecordTime();
-    this.spanTimeInternal = tracingModel.maximumRecordTime() - this.zeroTimeInternal;
+    this.#zeroTimeInternal = zeroTime || tracingModel.minimumRecordTime();
+    this.#spanTimeInternal = tracingModel.maximumRecordTime() - this.#zeroTimeInternal;
 
-    this.framesInternal = [];
+    this.#framesInternal = [];
     const browserMain = TracingModel.browserMainThread(tracingModel);
     if (!browserMain) {
       return;
@@ -32,7 +32,7 @@ export class FilmStripModel {
     const events = browserMain.events();
     for (let i = 0; i < events.length; ++i) {
       const event = events[i];
-      if (event.startTime < this.zeroTimeInternal) {
+      if (event.startTime < this.#zeroTimeInternal) {
         continue;
       }
       if (!event.hasCategory(category)) {
@@ -41,31 +41,31 @@ export class FilmStripModel {
       if (event.name === TraceEvents.CaptureFrame) {
         const data = event.args['data'];
         if (data) {
-          this.framesInternal.push(Frame.fromEvent(this, event, this.framesInternal.length));
+          this.#framesInternal.push(Frame.fromEvent(this, event, this.#framesInternal.length));
         }
       } else if (event.name === TraceEvents.Screenshot) {
-        this.framesInternal.push(Frame.fromSnapshot(this, (event as ObjectSnapshot), this.framesInternal.length));
+        this.#framesInternal.push(Frame.fromSnapshot(this, (event as ObjectSnapshot), this.#framesInternal.length));
       }
     }
   }
 
   frames(): Frame[] {
-    return this.framesInternal;
+    return this.#framesInternal;
   }
 
   zeroTime(): number {
-    return this.zeroTimeInternal;
+    return this.#zeroTimeInternal;
   }
 
   spanTime(): number {
-    return this.spanTimeInternal;
+    return this.#spanTimeInternal;
   }
 
   frameByTimestamp(timestamp: number): Frame|null {
     const index = Platform.ArrayUtilities.upperBound(
-                      this.framesInternal, timestamp, (timestamp, frame) => timestamp - frame.timestamp) -
+                      this.#framesInternal, timestamp, (timestamp, frame) => timestamp - frame.timestamp) -
         1;
-    return index >= 0 ? this.framesInternal[index] : null;
+    return index >= 0 ? this.#framesInternal[index] : null;
   }
 }
 
@@ -77,40 +77,40 @@ const TraceEvents = {
 };
 
 export class Frame {
-  private readonly modelInternal: FilmStripModel;
+  readonly #modelInternal: FilmStripModel;
   timestamp: number;
   index: number;
-  private imageData: string|null;
-  private snapshot: ObjectSnapshot|null;
+  #imageData: string|null;
+  #snapshot: ObjectSnapshot|null;
   constructor(model: FilmStripModel, timestamp: number, index: number) {
-    this.modelInternal = model;
+    this.#modelInternal = model;
     this.timestamp = timestamp;
     this.index = index;
-    this.imageData = null;
-    this.snapshot = null;
+    this.#imageData = null;
+    this.#snapshot = null;
   }
 
   static fromEvent(model: FilmStripModel, event: Event, index: number): Frame {
     const frame = new Frame(model, event.startTime, index);
-    frame.imageData = event.args['data'];
+    frame.#imageData = event.args['data'];
     return frame;
   }
 
   static fromSnapshot(model: FilmStripModel, snapshot: ObjectSnapshot, index: number): Frame {
     const frame = new Frame(model, snapshot.startTime, index);
-    frame.snapshot = snapshot;
+    frame.#snapshot = snapshot;
     return frame;
   }
 
   model(): FilmStripModel {
-    return this.modelInternal;
+    return this.#modelInternal;
   }
 
   imageDataPromise(): Promise<string|null> {
-    if (this.imageData || !this.snapshot) {
-      return Promise.resolve(this.imageData);
+    if (this.#imageData || !this.#snapshot) {
+      return Promise.resolve(this.#imageData);
     }
 
-    return this.snapshot.objectPromise() as Promise<string|null>;
+    return this.#snapshot.objectPromise() as Promise<string|null>;
   }
 }