chrome-devtools-frontend 1.0.1512147 → 1.0.1513662

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -308,9 +308,9 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
   readonly uiSourceCode: Workspace.UISourceCode.UISourceCode;
   readonly script: SDK.Script.Script|null;
   #scriptSource?: string|null;
-  #isDivergingFromVMInternal?: boolean;
-  #hasDivergedFromVMInternal?: boolean;
-  #isMergingToVMInternal?: boolean;
+  #isDivergingFromVM?: boolean;
+  #hasDivergedFromVM?: boolean;
+  #isMergingToVM?: boolean;
   #updateMutex = new Common.Mutex.Mutex();
   constructor(
       resourceScriptMapping: ResourceScriptMapping, uiSourceCode: Workspace.UISourceCode.UISourceCode,
@@ -414,9 +414,9 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
     // Do not interleave "divergeFromVM" with "mergeToVM" calls.
     const release = await this.#updateMutex.acquire();
     const diverged = this.isDiverged();
-    if (diverged && !this.#hasDivergedFromVMInternal) {
+    if (diverged && !this.#hasDivergedFromVM) {
       await this.divergeFromVM();
-    } else if (!diverged && this.#hasDivergedFromVMInternal) {
+    } else if (!diverged && this.#hasDivergedFromVM) {
       await this.mergeToVM();
     }
     release();
@@ -424,34 +424,34 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
 
   private async divergeFromVM(): Promise<void> {
     if (this.script) {
-      this.#isDivergingFromVMInternal = true;
+      this.#isDivergingFromVM = true;
       await this.#resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.script);
-      this.#isDivergingFromVMInternal = undefined;
-      this.#hasDivergedFromVMInternal = true;
+      this.#isDivergingFromVM = undefined;
+      this.#hasDivergedFromVM = true;
       this.dispatchEventToListeners(ResourceScriptFile.Events.DID_DIVERGE_FROM_VM);
     }
   }
 
   private async mergeToVM(): Promise<void> {
     if (this.script) {
-      this.#hasDivergedFromVMInternal = undefined;
-      this.#isMergingToVMInternal = true;
+      this.#hasDivergedFromVM = undefined;
+      this.#isMergingToVM = true;
       await this.#resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.script);
-      this.#isMergingToVMInternal = undefined;
+      this.#isMergingToVM = undefined;
       this.dispatchEventToListeners(ResourceScriptFile.Events.DID_MERGE_TO_VM);
     }
   }
 
   hasDivergedFromVM(): boolean {
-    return Boolean(this.#hasDivergedFromVMInternal);
+    return Boolean(this.#hasDivergedFromVM);
   }
 
   isDivergingFromVM(): boolean {
-    return Boolean(this.#isDivergingFromVMInternal);
+    return Boolean(this.#isDivergingFromVM);
   }
 
   isMergingToVM(): boolean {
-    return Boolean(this.#isMergingToVMInternal);
+    return Boolean(this.#isMergingToVM);
   }
 
   checkMapping(): void {

package/front_end/models/elements/ElementUpdateRecord.ts

@@ -37,9 +37,9 @@ import type * as SDK from '../../core/sdk/sdk.js';
 export class ElementUpdateRecord {
   private modifiedAttributes?: Set<string>;
   private removedAttributes?: Set<string>;
-  private hasChangedChildrenInternal?: boolean;
-  private hasRemovedChildrenInternal?: boolean;
-  private charDataModifiedInternal?: boolean;
+  #hasChangedChildren?: boolean;
+  #hasRemovedChildren?: boolean;
+  #charDataModified?: boolean;
 
   attributeModified(attrName: string): void {
     if (this.removedAttributes?.has(attrName)) {
@@ -62,20 +62,20 @@ export class ElementUpdateRecord {
   }
 
   nodeInserted(_node: SDK.DOMModel.DOMNode): void {
-    this.hasChangedChildrenInternal = true;
+    this.#hasChangedChildren = true;
   }
 
   nodeRemoved(_node: SDK.DOMModel.DOMNode): void {
-    this.hasChangedChildrenInternal = true;
-    this.hasRemovedChildrenInternal = true;
+    this.#hasChangedChildren = true;
+    this.#hasRemovedChildren = true;
   }
 
   charDataModified(): void {
-    this.charDataModifiedInternal = true;
+    this.#charDataModified = true;
   }
 
   childrenModified(): void {
-    this.hasChangedChildrenInternal = true;
+    this.#hasChangedChildren = true;
   }
 
   isAttributeModified(attributeName: string): boolean {
@@ -88,14 +88,14 @@ export class ElementUpdateRecord {
   }
 
   isCharDataModified(): boolean {
-    return Boolean(this.charDataModifiedInternal);
+    return Boolean(this.#charDataModified);
   }
 
   hasChangedChildren(): boolean {
-    return Boolean(this.hasChangedChildrenInternal);
+    return Boolean(this.#hasChangedChildren);
   }
 
   hasRemovedChildren(): boolean {
-    return Boolean(this.hasRemovedChildrenInternal);
+    return Boolean(this.#hasRemovedChildren);
   }
 }

package/front_end/models/emulation/DeviceModeModel.ts

@@ -88,50 +88,50 @@ let deviceModeModelInstance: DeviceModeModel|null;
 
 export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDK.TargetManager.SDKModelObserver<SDK.EmulationModel.EmulationModel> {
-  #screenRectInternal: Rect;
-  #visiblePageRectInternal: Rect;
+  #screenRect: Rect;
+  #visiblePageRect: Rect;
   #availableSize: Geometry.Size;
   #preferredSize: Geometry.Size;
   #initialized: boolean;
-  #appliedDeviceSizeInternal: Geometry.Size;
-  #appliedDeviceScaleFactorInternal: number;
-  #appliedUserAgentTypeInternal: UA;
-  readonly #scaleSettingInternal: Common.Settings.Setting<number>;
-  #scaleInternal: number;
+  #appliedDeviceSize: Geometry.Size;
+  #appliedDeviceScaleFactor: number;
+  #appliedUserAgentType: UA;
+  readonly #scaleSetting: Common.Settings.Setting<number>;
+  #scale: number;
   #widthSetting: Common.Settings.Setting<number>;
   #heightSetting: Common.Settings.Setting<number>;
-  #uaSettingInternal: Common.Settings.Setting<UA>;
-  readonly #deviceScaleFactorSettingInternal: Common.Settings.Setting<number>;
-  readonly #deviceOutlineSettingInternal: Common.Settings.Setting<boolean>;
-  readonly #toolbarControlsEnabledSettingInternal: Common.Settings.Setting<boolean>;
-  #typeInternal: Type;
-  #deviceInternal: EmulatedDevice|null;
-  #modeInternal: Mode|null;
-  #fitScaleInternal: number;
+  #uaSetting: Common.Settings.Setting<UA>;
+  readonly #deviceScaleFactorSetting: Common.Settings.Setting<number>;
+  readonly #deviceOutlineSetting: Common.Settings.Setting<boolean>;
+  readonly #toolbarControlsEnabledSetting: Common.Settings.Setting<boolean>;
+  #type: Type;
+  #device: EmulatedDevice|null;
+  #mode: Mode|null;
+  #fitScale: number;
   #touchEnabled: boolean;
   #touchMobile: boolean;
   #emulationModel: SDK.EmulationModel.EmulationModel|null;
   #onModelAvailable: (() => void)|null;
-  #outlineRectInternal?: Rect;
+  #outlineRect?: Rect;
 
   private constructor() {
     super();
-    this.#screenRectInternal = new Rect(0, 0, 1, 1);
-    this.#visiblePageRectInternal = new Rect(0, 0, 1, 1);
+    this.#screenRect = new Rect(0, 0, 1, 1);
+    this.#visiblePageRect = new Rect(0, 0, 1, 1);
     this.#availableSize = new Geometry.Size(1, 1);
     this.#preferredSize = new Geometry.Size(1, 1);
     this.#initialized = false;
-    this.#appliedDeviceSizeInternal = new Geometry.Size(1, 1);
-    this.#appliedDeviceScaleFactorInternal = window.devicePixelRatio;
-    this.#appliedUserAgentTypeInternal = UA.DESKTOP;
+    this.#appliedDeviceSize = new Geometry.Size(1, 1);
+    this.#appliedDeviceScaleFactor = window.devicePixelRatio;
+    this.#appliedUserAgentType = UA.DESKTOP;
 
-    this.#scaleSettingInternal = Common.Settings.Settings.instance().createSetting('emulation.device-scale', 1);
+    this.#scaleSetting = Common.Settings.Settings.instance().createSetting('emulation.device-scale', 1);
     // We've used to allow zero before.
-    if (!this.#scaleSettingInternal.get()) {
-      this.#scaleSettingInternal.set(1);
+    if (!this.#scaleSetting.get()) {
+      this.#scaleSetting.set(1);
     }
-    this.#scaleSettingInternal.addChangeListener(this.scaleSettingChanged, this);
-    this.#scaleInternal = 1;
+    this.#scaleSetting.addChangeListener(this.scaleSettingChanged, this);
+    this.#scale = 1;
 
     this.#widthSetting = Common.Settings.Settings.instance().createSetting('emulation.device-width', 400);
     if (this.#widthSetting.get() < MinDeviceSize) {
@@ -151,23 +151,22 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     }
     this.#heightSetting.addChangeListener(this.heightSettingChanged, this);
 
-    this.#uaSettingInternal = Common.Settings.Settings.instance().createSetting('emulation.device-ua', UA.MOBILE);
-    this.#uaSettingInternal.addChangeListener(this.uaSettingChanged, this);
-    this.#deviceScaleFactorSettingInternal =
+    this.#uaSetting = Common.Settings.Settings.instance().createSetting('emulation.device-ua', UA.MOBILE);
+    this.#uaSetting.addChangeListener(this.uaSettingChanged, this);
+    this.#deviceScaleFactorSetting =
         Common.Settings.Settings.instance().createSetting('emulation.device-scale-factor', 0);
-    this.#deviceScaleFactorSettingInternal.addChangeListener(this.deviceScaleFactorSettingChanged, this);
+    this.#deviceScaleFactorSetting.addChangeListener(this.deviceScaleFactorSettingChanged, this);
 
-    this.#deviceOutlineSettingInternal =
-        Common.Settings.Settings.instance().moduleSetting('emulation.show-device-outline');
-    this.#deviceOutlineSettingInternal.addChangeListener(this.deviceOutlineSettingChanged, this);
+    this.#deviceOutlineSetting = Common.Settings.Settings.instance().moduleSetting('emulation.show-device-outline');
+    this.#deviceOutlineSetting.addChangeListener(this.deviceOutlineSettingChanged, this);
 
-    this.#toolbarControlsEnabledSettingInternal = Common.Settings.Settings.instance().createSetting(
+    this.#toolbarControlsEnabledSetting = Common.Settings.Settings.instance().createSetting(
         'emulation.toolbar-controls-enabled', true, Common.Settings.SettingStorageType.SESSION);
 
-    this.#typeInternal = Type.None;
-    this.#deviceInternal = null;
-    this.#modeInternal = null;
-    this.#fitScaleInternal = 1;
+    this.#type = Type.None;
+    this.#device = null;
+    this.#mode = null;
+    this.#fitScale = 1;
     this.#touchEnabled = false;
     this.#touchMobile = false;
 
@@ -267,7 +266,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   get scaleSettingInternal(): Common.Settings.Setting<number> {
-    return this.#scaleSettingInternal;
+    return this.#scaleSetting;
   }
 
   setAvailableSize(availableSize: Geometry.Size, preferredSize: Geometry.Size): void {
@@ -278,23 +277,22 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   emulate(type: Type, device: EmulatedDevice|null, mode: Mode|null, scale?: number): void {
-    const resetPageScaleFactor =
-        this.#typeInternal !== type || this.#deviceInternal !== device || this.#modeInternal !== mode;
-    this.#typeInternal = type;
+    const resetPageScaleFactor = this.#type !== type || this.#device !== device || this.#mode !== mode;
+    this.#type = type;
 
     if (type === Type.Device && device && mode) {
       console.assert(Boolean(device) && Boolean(mode), 'Must pass device and mode for device emulation');
-      this.#modeInternal = mode;
-      this.#deviceInternal = device;
+      this.#mode = mode;
+      this.#device = device;
       if (this.#initialized) {
         const orientation = device.orientationByName(mode.orientation);
-        this.#scaleSettingInternal.set(
+        this.#scaleSetting.set(
             scale ||
             this.calculateFitScale(orientation.width, orientation.height, this.currentOutline(), this.currentInsets()));
       }
     } else {
-      this.#deviceInternal = null;
-      this.#modeInternal = null;
+      this.#device = null;
+      this.#mode = null;
     }
 
     if (type !== Type.None) {
@@ -311,7 +309,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
 
   setWidthAndScaleToFit(width: number): void {
     width = Math.max(Math.min(width, MaxDeviceSize), 1);
-    this.#scaleSettingInternal.set(this.calculateFitScale(width, this.#heightSetting.get()));
+    this.#scaleSetting.set(this.calculateFitScale(width, this.#heightSetting.get()));
     this.#widthSetting.set(width);
   }
 
@@ -326,66 +324,65 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
 
   setHeightAndScaleToFit(height: number): void {
     height = Math.max(Math.min(height, MaxDeviceSize), 0);
-    this.#scaleSettingInternal.set(this.calculateFitScale(this.#widthSetting.get(), height));
+    this.#scaleSetting.set(this.calculateFitScale(this.#widthSetting.get(), height));
     this.#heightSetting.set(height);
   }
 
   setScale(scale: number): void {
-    this.#scaleSettingInternal.set(scale);
+    this.#scaleSetting.set(scale);
   }
 
   device(): EmulatedDevice|null {
-    return this.#deviceInternal;
+    return this.#device;
   }
 
   mode(): Mode|null {
-    return this.#modeInternal;
+    return this.#mode;
   }
 
   type(): Type {
-    return this.#typeInternal;
+    return this.#type;
   }
 
   screenImage(): string {
-    return (this.#deviceInternal && this.#modeInternal) ? this.#deviceInternal.modeImage(this.#modeInternal) : '';
+    return (this.#device && this.#mode) ? this.#device.modeImage(this.#mode) : '';
   }
 
   outlineImage(): string {
-    return (this.#deviceInternal && this.#modeInternal && this.#deviceOutlineSettingInternal.get()) ?
-        this.#deviceInternal.outlineImage(this.#modeInternal) :
-        '';
+    return (this.#device && this.#mode && this.#deviceOutlineSetting.get()) ? this.#device.outlineImage(this.#mode) :
+                                                                              '';
   }
 
   outlineRect(): Rect|null {
-    return this.#outlineRectInternal || null;
+    return this.#outlineRect || null;
   }
 
   screenRect(): Rect {
-    return this.#screenRectInternal;
+    return this.#screenRect;
   }
 
   visiblePageRect(): Rect {
-    return this.#visiblePageRectInternal;
+    return this.#visiblePageRect;
   }
 
   scale(): number {
-    return this.#scaleInternal;
+    return this.#scale;
   }
 
   fitScale(): number {
-    return this.#fitScaleInternal;
+    return this.#fitScale;
   }
 
   appliedDeviceSize(): Geometry.Size {
-    return this.#appliedDeviceSizeInternal;
+    return this.#appliedDeviceSize;
   }
 
   appliedDeviceScaleFactor(): number {
-    return this.#appliedDeviceScaleFactorInternal;
+    return this.#appliedDeviceScaleFactor;
   }
 
   appliedUserAgentType(): UA {
-    return this.#appliedUserAgentTypeInternal;
+    return this.#appliedUserAgentType;
   }
 
   isFullHeight(): boolean {
@@ -393,13 +390,13 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   isMobile(): boolean {
-    switch (this.#typeInternal) {
+    switch (this.#type) {
       case Type.Device:
-        return this.#deviceInternal ? this.#deviceInternal.mobile() : false;
+        return this.#device ? this.#device.mobile() : false;
       case Type.None:
         return false;
       case Type.Responsive:
-        return this.#uaSettingInternal.get() === UA.MOBILE || this.#uaSettingInternal.get() === UA.MOBILE_NO_TOUCH;
+        return this.#uaSetting.get() === UA.MOBILE || this.#uaSetting.get() === UA.MOBILE_NO_TOUCH;
     }
     return false;
   }
@@ -409,31 +406,31 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   scaleSetting(): Common.Settings.Setting<number> {
-    return this.#scaleSettingInternal;
+    return this.#scaleSetting;
   }
 
   uaSetting(): Common.Settings.Setting<UA> {
-    return this.#uaSettingInternal;
+    return this.#uaSetting;
   }
 
   deviceScaleFactorSetting(): Common.Settings.Setting<number> {
-    return this.#deviceScaleFactorSettingInternal;
+    return this.#deviceScaleFactorSetting;
   }
 
   deviceOutlineSetting(): Common.Settings.Setting<boolean> {
-    return this.#deviceOutlineSettingInternal;
+    return this.#deviceOutlineSetting;
   }
 
   toolbarControlsEnabledSetting(): Common.Settings.Setting<boolean> {
-    return this.#toolbarControlsEnabledSettingInternal;
+    return this.#toolbarControlsEnabledSetting;
   }
 
   reset(): void {
-    this.#deviceScaleFactorSettingInternal.set(0);
-    this.#scaleSettingInternal.set(1);
+    this.#deviceScaleFactorSetting.set(0);
+    this.#scaleSetting.set(1);
     this.setWidth(400);
     this.setHeight(0);
-    this.#uaSettingInternal.set(UA.MOBILE);
+    this.#uaSetting.set(UA.MOBILE);
   }
 
   modelAdded(emulationModel: SDK.EmulationModel.EmulationModel): void {
@@ -499,37 +496,37 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   private preferredScaledWidth(): number {
-    return Math.floor(this.#preferredSize.width / (this.#scaleSettingInternal.get() || 1));
+    return Math.floor(this.#preferredSize.width / (this.#scaleSetting.get() || 1));
   }
 
   private preferredScaledHeight(): number {
-    return Math.floor(this.#preferredSize.height / (this.#scaleSettingInternal.get() || 1));
+    return Math.floor(this.#preferredSize.height / (this.#scaleSetting.get() || 1));
   }
 
   private currentOutline(): Insets {
     let outline: Insets = new Insets(0, 0, 0, 0);
-    if (this.#typeInternal !== Type.Device || !this.#deviceInternal || !this.#modeInternal) {
+    if (this.#type !== Type.Device || !this.#device || !this.#mode) {
       return outline;
     }
-    const orientation = this.#deviceInternal.orientationByName(this.#modeInternal.orientation);
-    if (this.#deviceOutlineSettingInternal.get()) {
+    const orientation = this.#device.orientationByName(this.#mode.orientation);
+    if (this.#deviceOutlineSetting.get()) {
       outline = orientation.outlineInsets || outline;
     }
     return outline;
   }
 
   private currentInsets(): Insets {
-    if (this.#typeInternal !== Type.Device || !this.#modeInternal) {
+    if (this.#type !== Type.Device || !this.#mode) {
       return new Insets(0, 0, 0, 0);
     }
-    return this.#modeInternal.insets;
+    return this.#mode.insets;
   }
 
   private getScreenOrientationType(): Protocol.Emulation.ScreenOrientationType {
-    if (!this.#modeInternal) {
+    if (!this.#mode) {
       throw new Error('Mode required to get orientation type.');
     }
-    switch (this.#modeInternal.orientation) {
+    switch (this.#mode.orientation) {
       case VerticalSpanned:
       case Vertical:
         return Protocol.Emulation.ScreenOrientationType.PortraitPrimary;
@@ -549,30 +546,30 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     if (overlayModel) {
       this.showHingeIfApplicable(overlayModel);
     }
-    if (this.#typeInternal === Type.Device && this.#deviceInternal && this.#modeInternal) {
-      const orientation = this.#deviceInternal.orientationByName(this.#modeInternal.orientation);
+    if (this.#type === Type.Device && this.#device && this.#mode) {
+      const orientation = this.#device.orientationByName(this.#mode.orientation);
       const outline = this.currentOutline();
       const insets = this.currentInsets();
-      this.#fitScaleInternal = this.calculateFitScale(orientation.width, orientation.height, outline, insets);
+      this.#fitScale = this.calculateFitScale(orientation.width, orientation.height, outline, insets);
       if (mobile) {
-        this.#appliedUserAgentTypeInternal = this.#deviceInternal.touch() ? UA.MOBILE : UA.MOBILE_NO_TOUCH;
+        this.#appliedUserAgentType = this.#device.touch() ? UA.MOBILE : UA.MOBILE_NO_TOUCH;
       } else {
-        this.#appliedUserAgentTypeInternal = this.#deviceInternal.touch() ? UA.DESKTOP_TOUCH : UA.DESKTOP;
+        this.#appliedUserAgentType = this.#device.touch() ? UA.DESKTOP_TOUCH : UA.DESKTOP;
       }
       this.applyDeviceMetrics(
-          new Geometry.Size(orientation.width, orientation.height), insets, outline, this.#scaleSettingInternal.get(),
-          this.#deviceInternal.deviceScaleFactor, mobile, this.getScreenOrientationType(), resetPageScaleFactor);
-      this.applyUserAgent(this.#deviceInternal.userAgent, this.#deviceInternal.userAgentMetadata);
-      this.applyTouch(this.#deviceInternal.touch(), mobile);
-    } else if (this.#typeInternal === Type.None) {
-      this.#fitScaleInternal = this.calculateFitScale(this.#availableSize.width, this.#availableSize.height);
-      this.#appliedUserAgentTypeInternal = UA.DESKTOP;
+          new Geometry.Size(orientation.width, orientation.height), insets, outline, this.#scaleSetting.get(),
+          this.#device.deviceScaleFactor, mobile, this.getScreenOrientationType(), resetPageScaleFactor);
+      this.applyUserAgent(this.#device.userAgent, this.#device.userAgentMetadata);
+      this.applyTouch(this.#device.touch(), mobile);
+    } else if (this.#type === Type.None) {
+      this.#fitScale = this.calculateFitScale(this.#availableSize.width, this.#availableSize.height);
+      this.#appliedUserAgentType = UA.DESKTOP;
       this.applyDeviceMetrics(
           this.#availableSize, new Insets(0, 0, 0, 0), new Insets(0, 0, 0, 0), 1, 0, mobile, null,
           resetPageScaleFactor);
       this.applyUserAgent('', null);
       this.applyTouch(false, false);
-    } else if (this.#typeInternal === Type.Responsive) {
+    } else if (this.#type === Type.Responsive) {
       let screenWidth = this.#widthSetting.get();
       if (!screenWidth || screenWidth > this.preferredScaledWidth()) {
         screenWidth = this.preferredScaledWidth();
@@ -582,23 +579,22 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
         screenHeight = this.preferredScaledHeight();
       }
       const defaultDeviceScaleFactor = mobile ? defaultMobileScaleFactor : 0;
-      this.#fitScaleInternal = this.calculateFitScale(this.#widthSetting.get(), this.#heightSetting.get());
-      this.#appliedUserAgentTypeInternal = this.#uaSettingInternal.get();
+      this.#fitScale = this.calculateFitScale(this.#widthSetting.get(), this.#heightSetting.get());
+      this.#appliedUserAgentType = this.#uaSetting.get();
       this.applyDeviceMetrics(
           new Geometry.Size(screenWidth, screenHeight), new Insets(0, 0, 0, 0), new Insets(0, 0, 0, 0),
-          this.#scaleSettingInternal.get(), this.#deviceScaleFactorSettingInternal.get() || defaultDeviceScaleFactor,
-          mobile,
+          this.#scaleSetting.get(), this.#deviceScaleFactorSetting.get() || defaultDeviceScaleFactor, mobile,
           screenHeight >= screenWidth ? Protocol.Emulation.ScreenOrientationType.PortraitPrimary :
                                         Protocol.Emulation.ScreenOrientationType.LandscapePrimary,
           resetPageScaleFactor);
       this.applyUserAgent(mobile ? defaultMobileUserAgent : '', mobile ? defaultMobileUserAgentMetadata : null);
       this.applyTouch(
-          this.#uaSettingInternal.get() === UA.DESKTOP_TOUCH || this.#uaSettingInternal.get() === UA.MOBILE,
-          this.#uaSettingInternal.get() === UA.MOBILE);
+          this.#uaSetting.get() === UA.DESKTOP_TOUCH || this.#uaSetting.get() === UA.MOBILE,
+          this.#uaSetting.get() === UA.MOBILE);
     }
 
     if (overlayModel) {
-      overlayModel.setShowViewportSizeOnResize(this.#typeInternal === Type.None);
+      overlayModel.setShowViewportSizeOnResize(this.#type === Type.None);
     }
     this.dispatchEventToListeners(Events.UPDATED);
   }
@@ -631,7 +627,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   setSizeAndScaleToFit(width: number, height: number): void {
-    this.#scaleSettingInternal.set(this.calculateFitScale(width, height));
+    this.#scaleSetting.set(this.calculateFitScale(width, height));
     this.setWidth(width);
     this.setHeight(height);
   }
@@ -655,20 +651,19 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     const screenOrientationAngle =
         screenOrientation === Protocol.Emulation.ScreenOrientationType.LandscapePrimary ? 90 : 0;
 
-    this.#appliedDeviceSizeInternal = screenSize;
-    this.#appliedDeviceScaleFactorInternal = deviceScaleFactor || window.devicePixelRatio;
-    this.#screenRectInternal = new Rect(
+    this.#appliedDeviceSize = screenSize;
+    this.#appliedDeviceScaleFactor = deviceScaleFactor || window.devicePixelRatio;
+    this.#screenRect = new Rect(
         Math.max(0, (this.#availableSize.width - screenSize.width * scale) / 2), outline.top * scale,
         screenSize.width * scale, screenSize.height * scale);
-    this.#outlineRectInternal = new Rect(
-        this.#screenRectInternal.left - outline.left * scale, 0,
-        (outline.left + screenSize.width + outline.right) * scale,
+    this.#outlineRect = new Rect(
+        this.#screenRect.left - outline.left * scale, 0, (outline.left + screenSize.width + outline.right) * scale,
         (outline.top + screenSize.height + outline.bottom) * scale);
-    this.#visiblePageRectInternal = new Rect(
+    this.#visiblePageRect = new Rect(
         positionX * scale, positionY * scale,
-        Math.min(pageWidth * scale, this.#availableSize.width - this.#screenRectInternal.left - positionX * scale),
-        Math.min(pageHeight * scale, this.#availableSize.height - this.#screenRectInternal.top - positionY * scale));
-    this.#scaleInternal = scale;
+        Math.min(pageWidth * scale, this.#availableSize.width - this.#screenRect.left - positionX * scale),
+        Math.min(pageHeight * scale, this.#availableSize.height - this.#screenRect.top - positionY * scale));
+    this.#scale = scale;
     const displayFeature = this.getDisplayFeature();
     if (!displayFeature) {
       // When sending displayFeature, we cannot use the optimization below due to backend restrictions.
@@ -678,9 +673,8 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
         pageWidth = 0;
         pageHeight = 0;
       }
-      if (this.#visiblePageRectInternal.width === pageWidth * scale &&
-          this.#visiblePageRectInternal.height === pageHeight * scale && Number.isInteger(pageWidth * scale) &&
-          Number.isInteger(pageHeight * scale)) {
+      if (this.#visiblePageRect.width === pageWidth * scale && this.#visiblePageRect.height === pageHeight * scale &&
+          Number.isInteger(pageWidth * scale) && Number.isInteger(pageHeight * scale)) {
         // When we only have to apply scale, do not resize the page. This will speed things up and remove lag.
         pageWidth = 0;
         pageHeight = 0;
@@ -763,8 +757,8 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       mobile: false,
     };
     if (fullSize && this.#emulationModel) {
-      if (this.#deviceInternal && this.#modeInternal) {
-        const orientation = this.#deviceInternal.orientationByName(this.#modeInternal.orientation);
+      if (this.#device && this.#mode) {
+        const orientation = this.#device.orientationByName(this.#mode.orientation);
         deviceMetrics.width = orientation.width;
         deviceMetrics.height = orientation.height;
         const dispFeature = this.getDisplayFeature();
@@ -793,9 +787,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   private showHingeIfApplicable(overlayModel: SDK.OverlayModel.OverlayModel): void {
-    const orientation = (this.#deviceInternal && this.#modeInternal) ?
-        this.#deviceInternal.orientationByName(this.#modeInternal.orientation) :
-        null;
+    const orientation = (this.#device && this.#mode) ? this.#device.orientationByName(this.#mode.orientation) : null;
     if (orientation?.hinge) {
       overlayModel.showHingeForDualScreen(orientation.hinge);
       return;
@@ -805,10 +797,10 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   private getDisplayFeatureOrientation(): Protocol.Emulation.DisplayFeatureOrientation {
-    if (!this.#modeInternal) {
+    if (!this.#mode) {
       throw new Error('Mode required to get display feature orientation.');
     }
-    switch (this.#modeInternal.orientation) {
+    switch (this.#mode.orientation) {
       case VerticalSpanned:
       case Vertical:
         return Protocol.Emulation.DisplayFeatureOrientation.Vertical;
@@ -820,12 +812,12 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   private getDisplayFeature(): Protocol.Emulation.DisplayFeature|null {
-    if (!this.#deviceInternal || !this.#modeInternal ||
-        (this.#modeInternal.orientation !== VerticalSpanned && this.#modeInternal.orientation !== HorizontalSpanned)) {
+    if (!this.#device || !this.#mode ||
+        (this.#mode.orientation !== VerticalSpanned && this.#mode.orientation !== HorizontalSpanned)) {
       return null;
     }
 
-    const orientation = this.#deviceInternal.orientationByName(this.#modeInternal.orientation);
+    const orientation = this.#device.orientationByName(this.#mode.orientation);
     if (!orientation?.hinge) {
       return null;
     }
@@ -833,8 +825,8 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     const hinge = orientation.hinge;
     return {
       orientation: this.getDisplayFeatureOrientation(),
-      offset: (this.#modeInternal.orientation === VerticalSpanned) ? hinge.x : hinge.y,
-      maskLength: (this.#modeInternal.orientation === VerticalSpanned) ? hinge.width : hinge.height,
+      offset: (this.#mode.orientation === VerticalSpanned) ? hinge.x : hinge.y,
+      maskLength: (this.#mode.orientation === VerticalSpanned) ? hinge.width : hinge.height,
     };
   }
 }