chrome-devtools-frontend 1.0.1512147 → 1.0.1513662

package/front_end/core/sdk/AnimationModel.ts

@@ -478,11 +478,11 @@ export interface EventTypes {
 
 export class AnimationImpl {
   readonly #animationModel: AnimationModel;
-  #payloadInternal!: Protocol.Animation
+  #payload!: Protocol.Animation
       .Animation;  // Assertion is safe because only way to create `AnimationImpl` is to use `parsePayload` which calls `setPayload` and sets the value.
-  #sourceInternal!:
+  #source!:
       AnimationEffect;  // Assertion is safe because only way to create `AnimationImpl` is to use `parsePayload` which calls `setPayload` and sets the value.
-  #playStateInternal?: string;
+  #playState?: string;
 
   private constructor(animationModel: AnimationModel) {
     this.#animationModel = animationModel;
@@ -508,11 +508,11 @@ export class AnimationImpl {
       }
     }
 
-    this.#payloadInternal = payload;
-    if (this.#sourceInternal && payload.source) {
-      this.#sourceInternal.setPayload(payload.source);
-    } else if (!this.#sourceInternal && payload.source) {
-      this.#sourceInternal = new AnimationEffect(this.#animationModel, payload.source);
+    this.#payload = payload;
+    if (this.#source && payload.source) {
+      this.#source.setPayload(payload.source);
+    } else if (!this.#source && payload.source) {
+      this.#source = new AnimationEffect(this.#animationModel, payload.source);
     }
   }
 
@@ -536,27 +536,27 @@ export class AnimationImpl {
   }
 
   viewOrScrollTimeline(): Protocol.Animation.ViewOrScrollTimeline|undefined {
-    return this.#payloadInternal.viewOrScrollTimeline;
+    return this.#payload.viewOrScrollTimeline;
   }
 
   id(): string {
-    return this.#payloadInternal.id;
+    return this.#payload.id;
   }
 
   name(): string {
-    return this.#payloadInternal.name;
+    return this.#payload.name;
   }
 
   paused(): boolean {
-    return this.#payloadInternal.pausedState;
+    return this.#payload.pausedState;
   }
 
   playState(): string {
-    return this.#playStateInternal || this.#payloadInternal.playState;
+    return this.#playState || this.#payload.playState;
   }
 
   playbackRate(): number {
-    return this.#payloadInternal.playbackRate;
+    return this.#payload.playbackRate;
   }
 
   // For scroll driven animations, it returns the pixel offset in the scroll container
@@ -565,12 +565,12 @@ export class AnimationImpl {
     const viewOrScrollTimeline = this.viewOrScrollTimeline();
     if (viewOrScrollTimeline) {
       return this.percentageToPixels(
-                 this.playbackRate() > 0 ? this.#payloadInternal.startTime : 100 - this.#payloadInternal.startTime,
+                 this.playbackRate() > 0 ? this.#payload.startTime : 100 - this.#payload.startTime,
                  viewOrScrollTimeline) +
           (this.viewOrScrollTimeline()?.startOffset ?? 0);
     }
 
-    return this.#payloadInternal.startTime;
+    return this.#payload.startTime;
   }
 
   // For scroll driven animations, it returns the duration in pixels (i.e. after how many pixels of scroll the animation is going to end)
@@ -615,18 +615,18 @@ export class AnimationImpl {
   currentTime(): number {
     const viewOrScrollTimeline = this.viewOrScrollTimeline();
     if (viewOrScrollTimeline) {
-      return this.percentageToPixels(this.#payloadInternal.currentTime, viewOrScrollTimeline);
+      return this.percentageToPixels(this.#payload.currentTime, viewOrScrollTimeline);
     }
 
-    return this.#payloadInternal.currentTime;
+    return this.#payload.currentTime;
   }
 
   source(): AnimationEffect {
-    return this.#sourceInternal;
+    return this.#source;
   }
 
   type(): Protocol.Animation.AnimationType {
-    return this.#payloadInternal.type;
+    return this.#payload.type;
   }
 
   overlaps(animation: AnimationImpl): boolean {
@@ -652,14 +652,14 @@ export class AnimationImpl {
   }
 
   setTiming(duration: number, delay: number): void {
-    void this.#sourceInternal.node().then(node => {
+    void this.#source.node().then(node => {
       if (!node) {
         throw new Error('Unable to find node');
       }
       this.updateNodeStyle(duration, delay, node);
     });
-    this.#sourceInternal.durationInternal = duration;
-    this.#sourceInternal.delayInternal = delay;
+    this.#source.durationInternal = duration;
+    this.#source.delayInternal = delay;
     void this.#animationModel.agent.invoke_setTiming({animationId: this.id(), duration, delay});
   }
 
@@ -692,7 +692,7 @@ export class AnimationImpl {
   }
 
   cssId(): string {
-    return this.#payloadInternal.cssId || '';
+    return this.#payload.cssId || '';
   }
 }
 
@@ -702,8 +702,8 @@ export class AnimationEffect {
       .AnimationEffect;       // Assertion is safe because `setPayload` call in `constructor` sets the value.
   delayInternal!: number;     // Assertion is safe because `setPayload` call in `constructor` sets the value.
   durationInternal!: number;  // Assertion is safe because `setPayload` call in `constructor` sets the value.
-  #keyframesRuleInternal: KeyframesRule|undefined;
-  #deferredNodeInternal?: DeferredDOMNode;
+  #keyframesRule: KeyframesRule|undefined;
+  #deferredNode?: DeferredDOMNode;
   constructor(animationModel: AnimationModel, payload: Protocol.Animation.AnimationEffect) {
     this.#animationModel = animationModel;
     this.setPayload(payload);
@@ -711,10 +711,10 @@ export class AnimationEffect {
 
   setPayload(payload: Protocol.Animation.AnimationEffect): void {
     this.#payload = payload;
-    if (!this.#keyframesRuleInternal && payload.keyframesRule) {
-      this.#keyframesRuleInternal = new KeyframesRule(payload.keyframesRule);
-    } else if (this.#keyframesRuleInternal && payload.keyframesRule) {
-      this.#keyframesRuleInternal.setPayload(payload.keyframesRule);
+    if (!this.#keyframesRule && payload.keyframesRule) {
+      this.#keyframesRule = new KeyframesRule(payload.keyframesRule);
+    } else if (this.#keyframesRule && payload.keyframesRule) {
+      this.#keyframesRule.setPayload(payload.keyframesRule);
     }
 
     this.delayInternal = payload.delay;
@@ -750,10 +750,10 @@ export class AnimationEffect {
   }
 
   node(): Promise<DOMNode|null> {
-    if (!this.#deferredNodeInternal) {
-      this.#deferredNodeInternal = new DeferredDOMNode(this.#animationModel.target(), this.backendNodeId());
+    if (!this.#deferredNode) {
+      this.#deferredNode = new DeferredDOMNode(this.#animationModel.target(), this.backendNodeId());
     }
-    return this.#deferredNodeInternal.resolvePromise();
+    return this.#deferredNode.resolvePromise();
   }
 
   deferredNode(): DeferredDOMNode {
@@ -765,7 +765,7 @@ export class AnimationEffect {
   }
 
   keyframesRule(): KeyframesRule|null {
-    return this.#keyframesRuleInternal || null;
+    return this.#keyframesRule || null;
   }
 
   easing(): string {
@@ -775,20 +775,19 @@ export class AnimationEffect {
 
 export class KeyframesRule {
   #payload!: Protocol.Animation
-      .KeyframesRule;  // Assertion is safe because `setPayload` call in `constructor` sets the value.;
-  #keyframesInternal!:
-      KeyframeStyle[];  // Assertion is safe because `setPayload` call in `constructor` sets the value.;
+      .KeyframesRule;            // Assertion is safe because `setPayload` call in `constructor` sets the value.;
+  #keyframes!: KeyframeStyle[];  // Assertion is safe because `setPayload` call in `constructor` sets the value.;
   constructor(payload: Protocol.Animation.KeyframesRule) {
     this.setPayload(payload);
   }
 
   setPayload(payload: Protocol.Animation.KeyframesRule): void {
     this.#payload = payload;
-    if (!this.#keyframesInternal) {
-      this.#keyframesInternal = this.#payload.keyframes.map(keyframeStyle => new KeyframeStyle(keyframeStyle));
+    if (!this.#keyframes) {
+      this.#keyframes = this.#payload.keyframes.map(keyframeStyle => new KeyframeStyle(keyframeStyle));
     } else {
       this.#payload.keyframes.forEach((keyframeStyle, index) => {
-        this.#keyframesInternal[index]?.setPayload(keyframeStyle);
+        this.#keyframes[index]?.setPayload(keyframeStyle);
       });
     }
   }
@@ -798,33 +797,33 @@ export class KeyframesRule {
   }
 
   keyframes(): KeyframeStyle[] {
-    return this.#keyframesInternal;
+    return this.#keyframes;
   }
 }
 
 export class KeyframeStyle {
   #payload!:
       Protocol.Animation.KeyframeStyle;  // Assertion is safe because `setPayload` call in `constructor` sets the value.
-  #offsetInternal!: string;              // Assertion is safe because `setPayload` call in `constructor` sets the value.
+  #offset!: string;                      // Assertion is safe because `setPayload` call in `constructor` sets the value.
   constructor(payload: Protocol.Animation.KeyframeStyle) {
     this.setPayload(payload);
   }
 
   setPayload(payload: Protocol.Animation.KeyframeStyle): void {
     this.#payload = payload;
-    this.#offsetInternal = payload.offset;
+    this.#offset = payload.offset;
   }
 
   offset(): string {
-    return this.#offsetInternal;
+    return this.#offset;
   }
 
   setOffset(offset: number): void {
-    this.#offsetInternal = offset * 100 + '%';
+    this.#offset = offset * 100 + '%';
   }
 
   offsetAsNumber(): number {
-    return parseFloat(this.#offsetInternal) / 100;
+    return parseFloat(this.#offset) / 100;
   }
 
   easing(): string {
@@ -834,27 +833,27 @@ export class KeyframeStyle {
 
 export class AnimationGroup {
   readonly #animationModel: AnimationModel;
-  readonly #idInternal: string;
-  #scrollNodeInternal: AnimationDOMNode|undefined;
-  #animationsInternal: AnimationImpl[];
-  #pausedInternal: boolean;
+  readonly #id: string;
+  #scrollNode: AnimationDOMNode|undefined;
+  #animations: AnimationImpl[];
+  #paused: boolean;
   constructor(animationModel: AnimationModel, id: string, animations: AnimationImpl[]) {
     this.#animationModel = animationModel;
-    this.#idInternal = id;
-    this.#animationsInternal = animations;
-    this.#pausedInternal = false;
+    this.#id = id;
+    this.#animations = animations;
+    this.#paused = false;
   }
 
   isScrollDriven(): boolean {
-    return Boolean(this.#animationsInternal[0]?.viewOrScrollTimeline());
+    return Boolean(this.#animations[0]?.viewOrScrollTimeline());
   }
 
   id(): string {
-    return this.#idInternal;
+    return this.#id;
   }
 
   animations(): AnimationImpl[] {
-    return this.#animationsInternal;
+    return this.#animations;
   }
 
   release(): void {
@@ -867,18 +866,18 @@ export class AnimationGroup {
       return animation.id();
     }
 
-    return this.#animationsInternal.map(extractId);
+    return this.#animations.map(extractId);
   }
 
   startTime(): number {
-    return this.#animationsInternal[0].startTime();
+    return this.#animations[0].startTime();
   }
 
   // For scroll driven animations, it returns the duration in pixels (i.e. after how many pixels of scroll the animation is going to end)
   // For time animations, it returns milliseconds.
   groupDuration(): number {
     let duration = 0;
-    for (const anim of this.#animationsInternal) {
+    for (const anim of this.#animations) {
       duration = Math.max(duration, anim.delayOrStartTime() + anim.iterationDuration());
     }
     return duration;
@@ -888,14 +887,14 @@ export class AnimationGroup {
   // For time animations, it returns milliseconds.
   finiteDuration(): number {
     let maxDuration = 0;
-    for (let i = 0; i < this.#animationsInternal.length; ++i) {
-      maxDuration = Math.max(maxDuration, this.#animationsInternal[i].finiteDuration());
+    for (let i = 0; i < this.#animations.length; ++i) {
+      maxDuration = Math.max(maxDuration, this.#animations[i].finiteDuration());
     }
     return maxDuration;
   }
 
   scrollOrientation(): Protocol.DOM.ScrollOrientation|null {
-    const timeline = this.#animationsInternal[0]?.viewOrScrollTimeline();
+    const timeline = this.#animations[0]?.viewOrScrollTimeline();
     if (!timeline) {
       return null;
     }
@@ -904,15 +903,15 @@ export class AnimationGroup {
   }
 
   async scrollNode(): Promise<AnimationDOMNode|null> {
-    if (this.#scrollNodeInternal) {
-      return this.#scrollNodeInternal;
+    if (this.#scrollNode) {
+      return this.#scrollNode;
     }
 
     if (!this.isScrollDriven()) {
       return null;
     }
 
-    const sourceNodeId = this.#animationsInternal[0]?.viewOrScrollTimeline()?.sourceNodeId;
+    const sourceNodeId = this.#animations[0]?.viewOrScrollTimeline()?.sourceNodeId;
     if (!sourceNodeId) {
       return null;
     }
@@ -923,8 +922,8 @@ export class AnimationGroup {
       return null;
     }
 
-    this.#scrollNodeInternal = new AnimationDOMNode(scrollNode);
-    return this.#scrollNodeInternal;
+    this.#scrollNode = new AnimationDOMNode(scrollNode);
+    return this.#scrollNode;
   }
 
   seekTo(currentTime: number): void {
@@ -932,20 +931,20 @@ export class AnimationGroup {
   }
 
   paused(): boolean {
-    return this.#pausedInternal;
+    return this.#paused;
   }
 
   togglePause(paused: boolean): void {
-    if (paused === this.#pausedInternal) {
+    if (paused === this.#paused) {
       return;
     }
-    this.#pausedInternal = paused;
+    this.#paused = paused;
     void this.#animationModel.agent.invoke_setPaused({animations: this.animationIds(), paused});
   }
 
   currentTimePromise(): Promise<number> {
     let longestAnim: AnimationImpl|null = null;
-    for (const anim of this.#animationsInternal) {
+    for (const anim of this.#animations) {
       if (!longestAnim || anim.endTime() > longestAnim.endTime()) {
         longestAnim = anim;
       }
@@ -967,11 +966,11 @@ export class AnimationGroup {
       return regularId + timelineId;
     }
 
-    if (this.#animationsInternal.length !== group.#animationsInternal.length) {
+    if (this.#animations.length !== group.#animations.length) {
       return false;
     }
-    const left = this.#animationsInternal.map(extractId).sort();
-    const right = group.#animationsInternal.map(extractId).sort();
+    const left = this.#animations.map(extractId).sort();
+    const right = group.#animations.map(extractId).sort();
     for (let i = 0; i < left.length; i++) {
       if (left[i] !== right[i]) {
         return false;
@@ -983,19 +982,19 @@ export class AnimationGroup {
   shouldInclude(group: AnimationGroup): boolean {
     // We want to include the animations coming from the incoming group
     // inside this group if they were to be grouped if the events came at the same time.
-    const [firstIncomingAnimation] = group.#animationsInternal;
-    const [firstAnimation] = this.#animationsInternal;
+    const [firstIncomingAnimation] = group.#animations;
+    const [firstAnimation] = this.#animations;
     return shouldGroupAnimations(firstAnimation, firstIncomingAnimation);
   }
 
   appendAnimations(animations: AnimationImpl[]): void {
-    this.#animationsInternal.push(...animations);
+    this.#animations.push(...animations);
   }
 
   rebaseTo(group: AnimationGroup): void {
     this.#animationModel.releaseAnimations(this.animationIds());
-    this.#animationsInternal = group.#animationsInternal;
-    this.#scrollNodeInternal = undefined;
+    this.#animations = group.#animations;
+    this.#scrollNode = undefined;
   }
 }
 

package/front_end/core/sdk/CPUProfilerModel.ts

@@ -52,7 +52,7 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
   #anonymousConsoleProfileIdToTitle: Map<string, string>;
   readonly #profilerAgent: ProtocolProxyApi.ProfilerApi;
   #preciseCoverageDeltaUpdateCallback: ((arg0: number, arg2: Protocol.Profiler.ScriptCoverage[]) => Promise<void>)|null;
-  readonly #debuggerModelInternal: DebuggerModel;
+  readonly #debuggerModel: DebuggerModel;
   readonly registeredConsoleProfileMessages: ProfileFinishedData[] = [];
 
   constructor(target: Target) {
@@ -63,15 +63,15 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
     this.#preciseCoverageDeltaUpdateCallback = null;
     target.registerProfilerDispatcher(this);
     void this.#profilerAgent.invoke_enable();
-    this.#debuggerModelInternal = (target.model(DebuggerModel) as DebuggerModel);
+    this.#debuggerModel = (target.model(DebuggerModel) as DebuggerModel);
   }
 
   runtimeModel(): RuntimeModel {
-    return this.#debuggerModelInternal.runtimeModel();
+    return this.#debuggerModel.runtimeModel();
   }
 
   debuggerModel(): DebuggerModel {
-    return this.#debuggerModelInternal;
+    return this.#debuggerModel;
   }
 
   consoleProfileStarted({id, location, title}: Protocol.Profiler.ConsoleProfileStartedEvent): void {
@@ -97,7 +97,7 @@ export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolPr
   }
 
   private createEventDataFrom(id: string, scriptLocation: Protocol.Debugger.Location, title?: string): EventData {
-    const debuggerLocation = Location.fromPayload(this.#debuggerModelInternal, scriptLocation);
+    const debuggerLocation = Location.fromPayload(this.#debuggerModel, scriptLocation);
     const globalId = this.target().id() + '.' + id;
     return {
       id: globalId,

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -39,14 +39,14 @@ let throttlingManagerInstance: CPUThrottlingManager;
 
 export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<EmulationModel> {
-  #cpuThrottlingOptionInternal: CPUThrottlingOption;
+  #cpuThrottlingOption: CPUThrottlingOption;
   #calibratedThrottlingSetting: Common.Settings.Setting<CalibratedCPUThrottling>;
-  #hardwareConcurrencyInternal?: number;
+  #hardwareConcurrency?: number;
   #pendingMainTargetPromise?: (r: number) => void;
 
   private constructor() {
     super();
-    this.#cpuThrottlingOptionInternal = NoThrottlingOption;
+    this.#cpuThrottlingOption = NoThrottlingOption;
     this.#calibratedThrottlingSetting = Common.Settings.Settings.instance().createSetting<CalibratedCPUThrottling>(
         'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
     this.#calibratedThrottlingSetting.addChangeListener(this.#onCalibratedSettingChanged, this);
@@ -63,21 +63,21 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   }
 
   cpuThrottlingRate(): number {
-    return this.#cpuThrottlingOptionInternal.rate();
+    return this.#cpuThrottlingOption.rate();
   }
 
   cpuThrottlingOption(): CPUThrottlingOption {
-    return this.#cpuThrottlingOptionInternal;
+    return this.#cpuThrottlingOption;
   }
 
   #onCalibratedSettingChanged(): void {
     // If a calibrated option is selected, need to propagate new rate.
-    const currentOption = this.#cpuThrottlingOptionInternal;
+    const currentOption = this.#cpuThrottlingOption;
     if (!currentOption.calibratedDeviceType) {
       return;
     }
 
-    const rate = this.#cpuThrottlingOptionInternal.rate();
+    const rate = this.#cpuThrottlingOption.rate();
     if (rate === 0) {
       // This calibrated option is no longer valid.
       this.setCPUThrottlingOption(NoThrottlingOption);
@@ -91,23 +91,23 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   }
 
   setCPUThrottlingOption(option: CPUThrottlingOption): void {
-    if (option === this.#cpuThrottlingOptionInternal) {
+    if (option === this.#cpuThrottlingOption) {
       return;
     }
 
-    this.#cpuThrottlingOptionInternal = option;
+    this.#cpuThrottlingOption = option;
     for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
-      void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOptionInternal.rate());
+      void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
     }
-    this.dispatchEventToListeners(Events.RATE_CHANGED, this.#cpuThrottlingOptionInternal.rate());
+    this.dispatchEventToListeners(Events.RATE_CHANGED, this.#cpuThrottlingOption.rate());
   }
 
   setHardwareConcurrency(concurrency: number): void {
-    this.#hardwareConcurrencyInternal = concurrency;
+    this.#hardwareConcurrency = concurrency;
     for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
       void emulationModel.setHardwareConcurrency(concurrency);
     }
-    this.dispatchEventToListeners(Events.HARDWARE_CONCURRENCY_CHANGED, this.#hardwareConcurrencyInternal);
+    this.dispatchEventToListeners(Events.HARDWARE_CONCURRENCY_CHANGED, this.#hardwareConcurrency);
   }
 
   hasPrimaryPageTargetSet(): boolean {
@@ -154,11 +154,11 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   }
 
   modelAdded(emulationModel: EmulationModel): void {
-    if (this.#cpuThrottlingOptionInternal !== NoThrottlingOption) {
-      void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOptionInternal.rate());
+    if (this.#cpuThrottlingOption !== NoThrottlingOption) {
+      void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
     }
-    if (this.#hardwareConcurrencyInternal !== undefined) {
-      void emulationModel.setHardwareConcurrency(this.#hardwareConcurrencyInternal);
+    if (this.#hardwareConcurrency !== undefined) {
+      void emulationModel.setHardwareConcurrency(this.#hardwareConcurrency);
     }
 
     // If there are any callers blocked on a getHardwareConcurrency call, let's wake them now.