chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/IsolateManager.ts

@@ -13,19 +13,19 @@ let isolateManagerInstance: IsolateManager;
 
 export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<RuntimeModel> {
-  private readonly isolatesInternal: Map<string, Isolate>;
-  private isolateIdByModel: Map<RuntimeModel, string|null>;
-  private observers: Set<Observer>;
-  private pollId: number;
+  readonly #isolatesInternal: Map<string, Isolate>;
+  #isolateIdByModel: Map<RuntimeModel, string|null>;
+  #observers: Set<Observer>;
+  #pollId: number;
 
   constructor() {
     super();
-    this.isolatesInternal = new Map();
-    // isolateIdByModel contains null while the isolateId is being retrieved.
-    this.isolateIdByModel = new Map();
-    this.observers = new Set();
+    this.#isolatesInternal = new Map();
+    // #isolateIdByModel contains null while the isolateId is being retrieved.
+    this.#isolateIdByModel = new Map();
+    this.#observers = new Set();
     TargetManager.instance().observeModels(RuntimeModel, this);
-    this.pollId = 0;
+    this.#pollId = 0;
   }
 
   static instance({forceNew}: {
@@ -39,22 +39,22 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
   }
 
   observeIsolates(observer: Observer): void {
-    if (this.observers.has(observer)) {
+    if (this.#observers.has(observer)) {
       throw new Error('Observer can only be registered once');
     }
-    if (!this.observers.size) {
+    if (!this.#observers.size) {
       this.poll();
     }
-    this.observers.add(observer);
-    for (const isolate of this.isolatesInternal.values()) {
+    this.#observers.add(observer);
+    for (const isolate of this.#isolatesInternal.values()) {
       observer.isolateAdded(isolate);
     }
   }
 
   unobserveIsolates(observer: Observer): void {
-    this.observers.delete(observer);
-    if (!this.observers.size) {
-      ++this.pollId;
+    this.#observers.delete(observer);
+    if (!this.#observers.size) {
+      ++this.#pollId;
     }  // Stops the current polling loop.
   }
 
@@ -63,68 +63,68 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
   }
 
   private async modelAddedInternal(model: RuntimeModel): Promise<void> {
-    this.isolateIdByModel.set(model, null);
+    this.#isolateIdByModel.set(model, null);
     const isolateId = await model.isolateId();
-    if (!this.isolateIdByModel.has(model)) {
+    if (!this.#isolateIdByModel.has(model)) {
       // The model has been removed during await.
       return;
     }
     if (!isolateId) {
-      this.isolateIdByModel.delete(model);
+      this.#isolateIdByModel.delete(model);
       return;
     }
-    this.isolateIdByModel.set(model, isolateId);
-    let isolate = this.isolatesInternal.get(isolateId);
+    this.#isolateIdByModel.set(model, isolateId);
+    let isolate = this.#isolatesInternal.get(isolateId);
     if (!isolate) {
       isolate = new Isolate(isolateId);
-      this.isolatesInternal.set(isolateId, isolate);
+      this.#isolatesInternal.set(isolateId, isolate);
     }
     isolate.modelsInternal.add(model);
     if (isolate.modelsInternal.size === 1) {
-      for (const observer of this.observers) {
+      for (const observer of this.#observers) {
         observer.isolateAdded(isolate);
       }
     } else {
-      for (const observer of this.observers) {
+      for (const observer of this.#observers) {
         observer.isolateChanged(isolate);
       }
     }
   }
 
   modelRemoved(model: RuntimeModel): void {
-    const isolateId = this.isolateIdByModel.get(model);
-    this.isolateIdByModel.delete(model);
+    const isolateId = this.#isolateIdByModel.get(model);
+    this.#isolateIdByModel.delete(model);
     if (!isolateId) {
       return;
     }
-    const isolate = this.isolatesInternal.get(isolateId);
+    const isolate = this.#isolatesInternal.get(isolateId);
     if (!isolate) {
       return;
     }
     isolate.modelsInternal.delete(model);
     if (isolate.modelsInternal.size) {
-      for (const observer of this.observers) {
+      for (const observer of this.#observers) {
         observer.isolateChanged(isolate);
       }
       return;
     }
-    for (const observer of this.observers) {
+    for (const observer of this.#observers) {
       observer.isolateRemoved(isolate);
     }
-    this.isolatesInternal.delete(isolateId);
+    this.#isolatesInternal.delete(isolateId);
   }
 
   isolateByModel(model: RuntimeModel): Isolate|null {
-    return this.isolatesInternal.get(this.isolateIdByModel.get(model) || '') || null;
+    return this.#isolatesInternal.get(this.#isolateIdByModel.get(model) || '') || null;
   }
 
   isolates(): Iterable<Isolate> {
-    return this.isolatesInternal.values();
+    return this.#isolatesInternal.values();
   }
 
   private async poll(): Promise<void> {
-    const pollId = this.pollId;
-    while (pollId === this.pollId) {
+    const pollId = this.#pollId;
+    while (pollId === this.#pollId) {
       await Promise.all(Array.from(this.isolates(), isolate => isolate.update()));
       await new Promise(r => setTimeout(r, PollIntervalMs));
     }
@@ -152,21 +152,21 @@ export const MemoryTrendWindowMs = 120e3;
 const PollIntervalMs = 2e3;
 
 export class Isolate {
-  private readonly idInternal: string;
+  readonly #idInternal: string;
   readonly modelsInternal: Set<RuntimeModel>;
-  private usedHeapSizeInternal: number;
-  private readonly memoryTrend: MemoryTrend;
+  #usedHeapSizeInternal: number;
+  readonly #memoryTrend: MemoryTrend;
 
   constructor(id: string) {
-    this.idInternal = id;
+    this.#idInternal = id;
     this.modelsInternal = new Set();
-    this.usedHeapSizeInternal = 0;
+    this.#usedHeapSizeInternal = 0;
     const count = MemoryTrendWindowMs / PollIntervalMs;
-    this.memoryTrend = new MemoryTrend(count);
+    this.#memoryTrend = new MemoryTrend(count);
   }
 
   id(): string {
-    return this.idInternal;
+    return this.#idInternal;
   }
 
   models(): Set<RuntimeModel> {
@@ -188,24 +188,24 @@ export class Isolate {
     if (!usage) {
       return;
     }
-    this.usedHeapSizeInternal = usage.usedSize;
-    this.memoryTrend.add(this.usedHeapSizeInternal);
+    this.#usedHeapSizeInternal = usage.usedSize;
+    this.#memoryTrend.add(this.#usedHeapSizeInternal);
     IsolateManager.instance().dispatchEventToListeners(Events.MemoryChanged, this);
   }
 
   samplesCount(): number {
-    return this.memoryTrend.count();
+    return this.#memoryTrend.count();
   }
 
   usedHeapSize(): number {
-    return this.usedHeapSizeInternal;
+    return this.#usedHeapSizeInternal;
   }
 
   /**
    * bytes per millisecond
    */
   usedHeapSizeGrowRate(): number {
-    return this.memoryTrend.fitSlope();
+    return this.#memoryTrend.fitSlope();
   }
 
   isMainThread(): boolean {
@@ -215,59 +215,59 @@ export class Isolate {
 }
 
 export class MemoryTrend {
-  private maxCount: number;
-  private base!: number;
-  private index!: number;
-  private x!: number[];
-  private y!: number[];
-  private sx!: number;
-  private sy!: number;
-  private sxx!: number;
-  private sxy!: number;
+  #maxCount: number;
+  #base!: number;
+  #index!: number;
+  #x!: number[];
+  #y!: number[];
+  #sx!: number;
+  #sy!: number;
+  #sxx!: number;
+  #sxy!: number;
   constructor(maxCount: number) {
-    this.maxCount = maxCount | 0;
+    this.#maxCount = maxCount | 0;
     this.reset();
   }
 
   reset(): void {
-    this.base = Date.now();
-    this.index = 0;
-    this.x = [];
-    this.y = [];
-    this.sx = 0;
-    this.sy = 0;
-    this.sxx = 0;
-    this.sxy = 0;
+    this.#base = Date.now();
+    this.#index = 0;
+    this.#x = [];
+    this.#y = [];
+    this.#sx = 0;
+    this.#sy = 0;
+    this.#sxx = 0;
+    this.#sxy = 0;
   }
 
   count(): number {
-    return this.x.length;
+    return this.#x.length;
   }
 
   add(heapSize: number, timestamp?: number): void {
-    const x = typeof timestamp === 'number' ? timestamp : Date.now() - this.base;
+    const x = typeof timestamp === 'number' ? timestamp : Date.now() - this.#base;
     const y = heapSize;
-    if (this.x.length === this.maxCount) {
-      // Turns into a cyclic buffer once it reaches the |maxCount|.
-      const x0 = this.x[this.index];
-      const y0 = this.y[this.index];
-      this.sx -= x0;
-      this.sy -= y0;
-      this.sxx -= x0 * x0;
-      this.sxy -= x0 * y0;
+    if (this.#x.length === this.#maxCount) {
+      // Turns into a cyclic buffer once it reaches the |#maxCount|.
+      const x0 = this.#x[this.#index];
+      const y0 = this.#y[this.#index];
+      this.#sx -= x0;
+      this.#sy -= y0;
+      this.#sxx -= x0 * x0;
+      this.#sxy -= x0 * y0;
     }
-    this.sx += x;
-    this.sy += y;
-    this.sxx += x * x;
-    this.sxy += x * y;
-    this.x[this.index] = x;
-    this.y[this.index] = y;
-    this.index = (this.index + 1) % this.maxCount;
+    this.#sx += x;
+    this.#sy += y;
+    this.#sxx += x * x;
+    this.#sxy += x * y;
+    this.#x[this.#index] = x;
+    this.#y[this.#index] = y;
+    this.#index = (this.#index + 1) % this.#maxCount;
   }
 
   fitSlope(): number {
     // We use the linear regression model to find the slope.
     const n = this.count();
-    return n < 2 ? 0 : (this.sxy - this.sx * this.sy / n) / (this.sxx - this.sx * this.sx / n);
+    return n < 2 ? 0 : (this.#sxy - this.#sx * this.#sy / n) / (this.#sxx - this.#sx * this.#sx / n);
   }
 }

package/front_end/core/sdk/IssuesModel.ts

@@ -16,8 +16,8 @@ import {SDKModel} from './SDKModel.js';
  * wants to preserve issues for targets (e.g. iframes) that are already gone as well.
  */
 export class IssuesModel extends SDKModel<EventTypes> implements ProtocolProxyApi.AuditsDispatcher {
-  private disposed = false;
-  private enabled = false;
+  #disposed = false;
+  #enabled = false;
 
   constructor(target: Target) {
     super(target);
@@ -25,11 +25,11 @@ export class IssuesModel extends SDKModel<EventTypes> implements ProtocolProxyAp
   }
 
   private async ensureEnabled(): Promise<void> {
-    if (this.enabled) {
+    if (this.#enabled) {
       return;
     }
 
-    this.enabled = true;
+    this.#enabled = true;
     this.target().registerAuditsDispatcher(this);
     const auditsAgent = this.target().auditsAgent();
     await auditsAgent.invoke_enable();
@@ -41,11 +41,11 @@ export class IssuesModel extends SDKModel<EventTypes> implements ProtocolProxyAp
 
   dispose(): void {
     super.dispose();
-    this.disposed = true;
+    this.#disposed = true;
   }
 
   getTargetIfNotDisposed(): Target|null {
-    if (!this.disposed) {
+    if (!this.#disposed) {
       return this.target();
     }
     return null;

package/front_end/core/sdk/LayerTreeBase.ts

@@ -49,82 +49,82 @@ export namespace Layer {
 }
 
 export class StickyPositionConstraint {
-  private readonly stickyBoxRectInternal: Protocol.DOM.Rect;
-  private readonly containingBlockRectInternal: Protocol.DOM.Rect;
-  private readonly nearestLayerShiftingStickyBoxInternal: Layer|null;
-  private readonly nearestLayerShiftingContainingBlockInternal: Layer|null;
+  readonly #stickyBoxRectInternal: Protocol.DOM.Rect;
+  readonly #containingBlockRectInternal: Protocol.DOM.Rect;
+  readonly #nearestLayerShiftingStickyBoxInternal: Layer|null;
+  readonly #nearestLayerShiftingContainingBlockInternal: Layer|null;
 
   constructor(layerTree: LayerTreeBase|null, constraint: Protocol.LayerTree.StickyPositionConstraint) {
-    this.stickyBoxRectInternal = constraint.stickyBoxRect;
-    this.containingBlockRectInternal = constraint.containingBlockRect;
-    this.nearestLayerShiftingStickyBoxInternal = null;
+    this.#stickyBoxRectInternal = constraint.stickyBoxRect;
+    this.#containingBlockRectInternal = constraint.containingBlockRect;
+    this.#nearestLayerShiftingStickyBoxInternal = null;
     if (layerTree && constraint.nearestLayerShiftingStickyBox) {
-      this.nearestLayerShiftingStickyBoxInternal = layerTree.layerById(constraint.nearestLayerShiftingStickyBox);
+      this.#nearestLayerShiftingStickyBoxInternal = layerTree.layerById(constraint.nearestLayerShiftingStickyBox);
     }
 
-    this.nearestLayerShiftingContainingBlockInternal = null;
+    this.#nearestLayerShiftingContainingBlockInternal = null;
     if (layerTree && constraint.nearestLayerShiftingContainingBlock) {
-      this.nearestLayerShiftingContainingBlockInternal =
+      this.#nearestLayerShiftingContainingBlockInternal =
           layerTree.layerById(constraint.nearestLayerShiftingContainingBlock);
     }
   }
 
   stickyBoxRect(): Protocol.DOM.Rect {
-    return this.stickyBoxRectInternal;
+    return this.#stickyBoxRectInternal;
   }
 
   containingBlockRect(): Protocol.DOM.Rect {
-    return this.containingBlockRectInternal;
+    return this.#containingBlockRectInternal;
   }
 
   nearestLayerShiftingStickyBox(): Layer|null {
-    return this.nearestLayerShiftingStickyBoxInternal;
+    return this.#nearestLayerShiftingStickyBoxInternal;
   }
 
   nearestLayerShiftingContainingBlock(): Layer|null {
-    return this.nearestLayerShiftingContainingBlockInternal;
+    return this.#nearestLayerShiftingContainingBlockInternal;
   }
 }
 
 export class LayerTreeBase {
-  private readonly targetInternal: Target|null;
-  private domModel: DOMModel|null;
+  readonly #targetInternal: Target|null;
+  #domModel: DOMModel|null;
   layersById: Map<string|number, Layer>;
-  private rootInternal: Layer|null;
-  private contentRootInternal: Layer|null;
-  private readonly backendNodeIdToNodeInternal: Map<Protocol.DOM.BackendNodeId, DOMNode|null>;
-  private viewportSizeInternal?: {
+  #rootInternal: Layer|null;
+  #contentRootInternal: Layer|null;
+  readonly #backendNodeIdToNodeInternal: Map<Protocol.DOM.BackendNodeId, DOMNode|null>;
+  #viewportSizeInternal?: {
     width: number,
     height: number,
   };
 
   constructor(target: Target|null) {
-    this.targetInternal = target;
-    this.domModel = target ? target.model(DOMModel) : null;
+    this.#targetInternal = target;
+    this.#domModel = target ? target.model(DOMModel) : null;
     this.layersById = new Map();
-    this.rootInternal = null;
-    this.contentRootInternal = null;
-    this.backendNodeIdToNodeInternal = new Map();
+    this.#rootInternal = null;
+    this.#contentRootInternal = null;
+    this.#backendNodeIdToNodeInternal = new Map();
   }
 
   target(): Target|null {
-    return this.targetInternal;
+    return this.#targetInternal;
   }
 
   root(): Layer|null {
-    return this.rootInternal;
+    return this.#rootInternal;
   }
 
   setRoot(root: Layer|null): void {
-    this.rootInternal = root;
+    this.#rootInternal = root;
   }
 
   contentRoot(): Layer|null {
-    return this.contentRootInternal;
+    return this.#contentRootInternal;
   }
 
   setContentRoot(contentRoot: Layer|null): void {
-    this.contentRootInternal = contentRoot;
+    this.#contentRootInternal = contentRoot;
   }
 
   forEachLayer<T>(callback: (arg0: Layer) => T, root?: Layer|null): T|boolean {
@@ -142,39 +142,39 @@ export class LayerTreeBase {
   }
 
   async resolveBackendNodeIds(requestedNodeIds: Set<Protocol.DOM.BackendNodeId>): Promise<void> {
-    if (!requestedNodeIds.size || !this.domModel) {
+    if (!requestedNodeIds.size || !this.#domModel) {
       return;
     }
 
-    const nodesMap = await this.domModel.pushNodesByBackendIdsToFrontend(requestedNodeIds);
+    const nodesMap = await this.#domModel.pushNodesByBackendIdsToFrontend(requestedNodeIds);
 
     if (!nodesMap) {
       return;
     }
     for (const nodeId of nodesMap.keys()) {
-      this.backendNodeIdToNodeInternal.set(nodeId, nodesMap.get(nodeId) || null);
+      this.#backendNodeIdToNodeInternal.set(nodeId, nodesMap.get(nodeId) || null);
     }
   }
 
   backendNodeIdToNode(): Map<Protocol.DOM.BackendNodeId, DOMNode|null> {
-    return this.backendNodeIdToNodeInternal;
+    return this.#backendNodeIdToNodeInternal;
   }
 
   setViewportSize(viewportSize: {
     width: number,
     height: number,
   }): void {
-    this.viewportSizeInternal = viewportSize;
+    this.#viewportSizeInternal = viewportSize;
   }
 
   viewportSize(): {
     width: number,
     height: number,
   }|undefined {
-    return this.viewportSizeInternal;
+    return this.#viewportSizeInternal;
   }
 
   private nodeForId(id: Protocol.DOM.NodeId): DOMNode|null {
-    return this.domModel ? this.domModel.nodeForId(id) : null;
+    return this.#domModel ? this.#domModel.nodeForId(id) : null;
   }
 }

package/front_end/core/sdk/LogModel.ts

@@ -11,14 +11,14 @@ import {Capability} from './Target.js';
 import {SDKModel} from './SDKModel.js';
 
 export class LogModel extends SDKModel<EventTypes> implements ProtocolProxyApi.LogDispatcher {
-  private readonly logAgent: ProtocolProxyApi.LogApi;
+  readonly #logAgent: ProtocolProxyApi.LogApi;
   constructor(target: Target) {
     super(target);
     target.registerLogDispatcher(this);
-    this.logAgent = target.logAgent();
-    this.logAgent.invoke_enable();
+    this.#logAgent = target.logAgent();
+    this.#logAgent.invoke_enable();
     if (!Host.InspectorFrontendHost.isUnderTest()) {
-      this.logAgent.invoke_startViolationsReport({
+      this.#logAgent.invoke_startViolationsReport({
         config: [
           {name: Protocol.Log.ViolationSettingName.LongTask, threshold: 200},
           {name: Protocol.Log.ViolationSettingName.LongLayout, threshold: 30},
@@ -37,7 +37,7 @@ export class LogModel extends SDKModel<EventTypes> implements ProtocolProxyApi.L
   }
 
   requestClear(): void {
-    this.logAgent.invoke_clear();
+    this.#logAgent.invoke_clear();
   }
 }