chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/FrameManager.ts

@@ -15,38 +15,38 @@ import {TargetManager} from './TargetManager.js';
 let frameManagerInstance: FrameManager|null = null;
 
 /**
- * The FrameManager is a central storage for all frames. It collects frames from all
- * ResourceTreeModel-instances (one per target), so that frames can be found by id
+ * The FrameManager is a central storage for all #frames. It collects #frames from all
+ * ResourceTreeModel-instances (one per target), so that #frames can be found by id
  * without needing to know their target.
  */
 export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<ResourceTreeModel> {
-  private readonly eventListeners: WeakMap<ResourceTreeModel, Common.EventTarget.EventDescriptor[]>;
-  private frames: Map<string, {
+  readonly #eventListeners: WeakMap<ResourceTreeModel, Common.EventTarget.EventDescriptor[]>;
+  #frames: Map<string, {
     frame: ResourceTreeFrame,
     count: number,
   }>;
-  private readonly framesForTarget: Map<Protocol.Target.TargetID|'main', Set<Protocol.Page.FrameId>>;
-  private topFrame: ResourceTreeFrame|null;
-  private creationStackTraceDataForTransferringFrame:
+  readonly #framesForTarget: Map<Protocol.Target.TargetID|'main', Set<Protocol.Page.FrameId>>;
+  #topFrame: ResourceTreeFrame|null;
+  #creationStackTraceDataForTransferringFrame:
       Map<string, {creationStackTrace: Protocol.Runtime.StackTrace | null, creationStackTraceTarget: Target}>;
-  private awaitedFrames: Map<string, {notInTarget?: Target, resolve: (frame: ResourceTreeFrame) => void}[]> = new Map();
+  #awaitedFrames: Map<string, {notInTarget?: Target, resolve: (frame: ResourceTreeFrame) => void}[]> = new Map();
 
   constructor() {
     super();
-    this.eventListeners = new WeakMap();
+    this.#eventListeners = new WeakMap();
     TargetManager.instance().observeModels(ResourceTreeModel, this);
 
-    // Maps frameIds to frames and a count of how many ResourceTreeModels contain this frame.
+    // Maps frameIds to #frames and a count of how many ResourceTreeModels contain this frame.
     // (OOPIFs are usually first attached to a new target and then detached from their old target,
     // therefore being contained in 2 models for a short period of time.)
-    this.frames = new Map();
+    this.#frames = new Map();
 
     // Maps targetIds to a set of frameIds.
-    this.framesForTarget = new Map();
+    this.#framesForTarget = new Map();
 
-    this.topFrame = null;
-    this.creationStackTraceDataForTransferringFrame = new Map();
+    this.#topFrame = null;
+    this.#creationStackTraceDataForTransferringFrame = new Map();
   }
 
   static instance({forceNew}: {
@@ -66,51 +66,52 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
         resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameNavigated, this.frameNavigated, this);
     const resourceAddedListener =
         resourceTreeModel.addEventListener(ResourceTreeModelEvents.ResourceAdded, this.resourceAdded, this);
-    this.eventListeners.set(resourceTreeModel, [addListener, detachListener, navigatedListener, resourceAddedListener]);
-    this.framesForTarget.set(resourceTreeModel.target().id(), new Set());
+    this.#eventListeners.set(
+        resourceTreeModel, [addListener, detachListener, navigatedListener, resourceAddedListener]);
+    this.#framesForTarget.set(resourceTreeModel.target().id(), new Set());
   }
 
   modelRemoved(resourceTreeModel: ResourceTreeModel): void {
-    const listeners = this.eventListeners.get(resourceTreeModel);
+    const listeners = this.#eventListeners.get(resourceTreeModel);
     if (listeners) {
       Common.EventTarget.removeEventListeners(listeners);
     }
 
-    // Iterate over this model's frames and decrease their count or remove them.
+    // Iterate over this model's #frames and decrease their count or remove them.
     // (The ResourceTreeModel does not send FrameDetached events when a model
     // is removed.)
-    const frameSet = this.framesForTarget.get(resourceTreeModel.target().id());
+    const frameSet = this.#framesForTarget.get(resourceTreeModel.target().id());
     if (frameSet) {
       for (const frameId of frameSet) {
         this.decreaseOrRemoveFrame(frameId);
       }
     }
-    this.framesForTarget.delete(resourceTreeModel.target().id());
+    this.#framesForTarget.delete(resourceTreeModel.target().id());
   }
 
   private frameAdded(event: Common.EventTarget.EventTargetEvent<ResourceTreeFrame>): void {
     const frame = event.data;
-    const frameData = this.frames.get(frame.id);
+    const frameData = this.#frames.get(frame.id);
     // If the frame is already in the map, increase its count, otherwise add it to the map.
     if (frameData) {
       // In order to not lose frame creation stack trace information during
       // an OOPIF transfer we need to copy it to the new frame
       frame.setCreationStackTrace(frameData.frame.getCreationStackTraceData());
-      this.frames.set(frame.id, {frame, count: frameData.count + 1});
+      this.#frames.set(frame.id, {frame, count: frameData.count + 1});
     } else {
       // If the transferring frame's detached event is received before its frame added
       // event in the new target, the persisted frame creation stacktrace is reassigned.
-      const traceData = this.creationStackTraceDataForTransferringFrame.get(frame.id);
+      const traceData = this.#creationStackTraceDataForTransferringFrame.get(frame.id);
       if (traceData && traceData.creationStackTrace) {
         frame.setCreationStackTrace(traceData);
       }
-      this.frames.set(frame.id, {frame, count: 1});
-      this.creationStackTraceDataForTransferringFrame.delete(frame.id);
+      this.#frames.set(frame.id, {frame, count: 1});
+      this.#creationStackTraceDataForTransferringFrame.delete(frame.id);
     }
     this.resetTopFrame();
 
     // Add the frameId to the the targetId's set of frameIds.
-    const frameSet = this.framesForTarget.get(frame.resourceTreeModel().target().id());
+    const frameSet = this.#framesForTarget.get(frame.resourceTreeModel().target().id());
     if (frameSet) {
       frameSet.add(frame.id);
     }
@@ -127,15 +128,15 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     // If the transferring frame's detached event is received before its frame
     // added event in the new target, we persist the frame creation stacktrace here
     // so that later on the frame added event in the new target it can be reassigned.
-    if (isSwap && !this.frames.get(frame.id)) {
+    if (isSwap && !this.#frames.get(frame.id)) {
       const traceData = frame.getCreationStackTraceData();
       if (traceData.creationStackTrace) {
-        this.creationStackTraceDataForTransferringFrame.set(frame.id, traceData);
+        this.#creationStackTraceDataForTransferringFrame.set(frame.id, traceData);
       }
     }
 
     // Remove the frameId from the target's set of frameIds.
-    const frameSet = this.framesForTarget.get(frame.resourceTreeModel().target().id());
+    const frameSet = this.#framesForTarget.get(frame.resourceTreeModel().target().id());
     if (frameSet) {
       frameSet.delete(frame.id);
     }
@@ -154,10 +155,10 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   }
 
   private decreaseOrRemoveFrame(frameId: Protocol.Page.FrameId): void {
-    const frameData = this.frames.get(frameId);
+    const frameData = this.#frames.get(frameId);
     if (frameData) {
       if (frameData.count === 1) {
-        this.frames.delete(frameId);
+        this.#frames.delete(frameId);
         this.resetTopFrame();
         this.dispatchEventToListeners(Events.FrameRemoved, {frameId});
       } else {
@@ -167,13 +168,13 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   }
 
   /**
-   * Looks for the top frame in `frames` and sets `topFrame` accordingly.
+   * Looks for the top frame in `#frames` and sets `#topFrame` accordingly.
    *
-   * Important: This method needs to be called everytime `frames` is updated.
+   * Important: This method needs to be called everytime `#frames` is updated.
    */
   private resetTopFrame(): void {
     const topFrames = this.getAllFrames().filter(frame => frame.isTopFrame());
-    this.topFrame = topFrames.length > 0 ? topFrames[0] : null;
+    this.#topFrame = topFrames.length > 0 ? topFrames[0] : null;
   }
 
   /**
@@ -184,7 +185,7 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
    * immediately use the function return value and not store it for later use.
    */
   getFrame(frameId: Protocol.Page.FrameId): ResourceTreeFrame|null {
-    const frameData = this.frames.get(frameId);
+    const frameData = this.#frames.get(frameId);
     if (frameData) {
       return frameData.frame;
     }
@@ -192,11 +193,11 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   }
 
   getAllFrames(): ResourceTreeFrame[] {
-    return Array.from(this.frames.values(), frameData => frameData.frame);
+    return Array.from(this.#frames.values(), frameData => frameData.frame);
   }
 
   getTopFrame(): ResourceTreeFrame|null {
-    return this.topFrame;
+    return this.#topFrame;
   }
 
   async getOrWaitForFrame(frameId: Protocol.Page.FrameId, notInTarget?: Target): Promise<ResourceTreeFrame> {
@@ -205,17 +206,17 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       return frame;
     }
     return new Promise<ResourceTreeFrame>(resolve => {
-      const waiting = this.awaitedFrames.get(frameId);
+      const waiting = this.#awaitedFrames.get(frameId);
       if (waiting) {
         waiting.push({notInTarget, resolve});
       } else {
-        this.awaitedFrames.set(frameId, [{notInTarget, resolve}]);
+        this.#awaitedFrames.set(frameId, [{notInTarget, resolve}]);
       }
     });
   }
 
   private resolveAwaitedFrame(frame: ResourceTreeFrame): void {
-    const waiting = this.awaitedFrames.get(frame.id);
+    const waiting = this.#awaitedFrames.get(frame.id);
     if (!waiting) {
       return;
     }
@@ -227,9 +228,9 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       return true;
     });
     if (newWaiting.length > 0) {
-      this.awaitedFrames.set(frame.id, newWaiting);
+      this.#awaitedFrames.set(frame.id, newWaiting);
     } else {
-      this.awaitedFrames.delete(frame.id);
+      this.#awaitedFrames.delete(frame.id);
     }
   }
 }

package/front_end/core/sdk/HeapProfilerModel.ts

@@ -13,57 +13,57 @@ import {Capability} from './Target.js';
 import {SDKModel} from './SDKModel.js';
 
 export class HeapProfilerModel extends SDKModel<EventTypes> {
-  private enabled: boolean;
-  private readonly heapProfilerAgent: ProtocolProxyApi.HeapProfilerApi;
-  private readonly memoryAgent: ProtocolProxyApi.MemoryApi;
-  private readonly runtimeModelInternal: RuntimeModel;
-  private samplingProfilerDepth: number;
+  #enabled: boolean;
+  readonly #heapProfilerAgent: ProtocolProxyApi.HeapProfilerApi;
+  readonly #memoryAgent: ProtocolProxyApi.MemoryApi;
+  readonly #runtimeModelInternal: RuntimeModel;
+  #samplingProfilerDepth: number;
 
   constructor(target: Target) {
     super(target);
     target.registerHeapProfilerDispatcher(new HeapProfilerDispatcher(this));
-    this.enabled = false;
-    this.heapProfilerAgent = target.heapProfilerAgent();
-    this.memoryAgent = target.memoryAgent();
-    this.runtimeModelInternal = (target.model(RuntimeModel) as RuntimeModel);
-    this.samplingProfilerDepth = 0;
+    this.#enabled = false;
+    this.#heapProfilerAgent = target.heapProfilerAgent();
+    this.#memoryAgent = target.memoryAgent();
+    this.#runtimeModelInternal = (target.model(RuntimeModel) as RuntimeModel);
+    this.#samplingProfilerDepth = 0;
   }
 
   debuggerModel(): DebuggerModel {
-    return this.runtimeModelInternal.debuggerModel();
+    return this.#runtimeModelInternal.debuggerModel();
   }
 
   runtimeModel(): RuntimeModel {
-    return this.runtimeModelInternal;
+    return this.#runtimeModelInternal;
   }
 
   async enable(): Promise<void> {
-    if (this.enabled) {
+    if (this.#enabled) {
       return;
     }
 
-    this.enabled = true;
-    await this.heapProfilerAgent.invoke_enable();
+    this.#enabled = true;
+    await this.#heapProfilerAgent.invoke_enable();
   }
 
   async startSampling(samplingRateInBytes?: number): Promise<boolean> {
-    if (this.samplingProfilerDepth++) {
+    if (this.#samplingProfilerDepth++) {
       return false;
     }
     const defaultSamplingIntervalInBytes = 16384;
-    const response = await this.heapProfilerAgent.invoke_startSampling(
+    const response = await this.#heapProfilerAgent.invoke_startSampling(
         {samplingInterval: samplingRateInBytes || defaultSamplingIntervalInBytes});
     return Boolean(response.getError());
   }
 
   async stopSampling(): Promise<Protocol.HeapProfiler.SamplingHeapProfile|null> {
-    if (!this.samplingProfilerDepth) {
+    if (!this.#samplingProfilerDepth) {
       throw new Error('Sampling profiler is not running.');
     }
-    if (--this.samplingProfilerDepth) {
+    if (--this.#samplingProfilerDepth) {
       return this.getSamplingProfile();
     }
-    const response = await this.heapProfilerAgent.invoke_stopSampling();
+    const response = await this.#heapProfilerAgent.invoke_stopSampling();
     if (response.getError()) {
       return null;
     }
@@ -71,7 +71,7 @@ export class HeapProfilerModel extends SDKModel<EventTypes> {
   }
 
   async getSamplingProfile(): Promise<Protocol.HeapProfiler.SamplingHeapProfile|null> {
-    const response = await this.heapProfilerAgent.invoke_getSamplingProfile();
+    const response = await this.#heapProfilerAgent.invoke_getSamplingProfile();
     if (response.getError()) {
       return null;
     }
@@ -79,12 +79,12 @@ export class HeapProfilerModel extends SDKModel<EventTypes> {
   }
 
   async collectGarbage(): Promise<boolean> {
-    const response = await this.heapProfilerAgent.invoke_collectGarbage();
+    const response = await this.#heapProfilerAgent.invoke_collectGarbage();
     return Boolean(response.getError());
   }
 
   async snapshotObjectIdForObjectId(objectId: Protocol.Runtime.RemoteObjectId): Promise<string|null> {
-    const response = await this.heapProfilerAgent.invoke_getHeapObjectId({objectId});
+    const response = await this.#heapProfilerAgent.invoke_getHeapObjectId({objectId});
     if (response.getError()) {
       return null;
     }
@@ -94,31 +94,31 @@ export class HeapProfilerModel extends SDKModel<EventTypes> {
   async objectForSnapshotObjectId(
       snapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId,
       objectGroupName: string): Promise<RemoteObject|null> {
-    const result = await this.heapProfilerAgent.invoke_getObjectByHeapObjectId(
+    const result = await this.#heapProfilerAgent.invoke_getObjectByHeapObjectId(
         {objectId: snapshotObjectId, objectGroup: objectGroupName});
     if (result.getError()) {
       return null;
     }
-    return this.runtimeModelInternal.createRemoteObject(result.result);
+    return this.#runtimeModelInternal.createRemoteObject(result.result);
   }
 
   async addInspectedHeapObject(snapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId): Promise<boolean> {
-    const response = await this.heapProfilerAgent.invoke_addInspectedHeapObject({heapObjectId: snapshotObjectId});
+    const response = await this.#heapProfilerAgent.invoke_addInspectedHeapObject({heapObjectId: snapshotObjectId});
     return Boolean(response.getError());
   }
 
   async takeHeapSnapshot(heapSnapshotOptions: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise<void> {
-    await this.heapProfilerAgent.invoke_takeHeapSnapshot(heapSnapshotOptions);
+    await this.#heapProfilerAgent.invoke_takeHeapSnapshot(heapSnapshotOptions);
   }
 
   async startTrackingHeapObjects(recordAllocationStacks: boolean): Promise<boolean> {
     const response =
-        await this.heapProfilerAgent.invoke_startTrackingHeapObjects({trackAllocations: recordAllocationStacks});
+        await this.#heapProfilerAgent.invoke_startTrackingHeapObjects({trackAllocations: recordAllocationStacks});
     return Boolean(response.getError());
   }
 
   async stopTrackingHeapObjects(reportProgress: boolean): Promise<boolean> {
-    const response = await this.heapProfilerAgent.invoke_stopTrackingHeapObjects({reportProgress});
+    const response = await this.#heapProfilerAgent.invoke_stopTrackingHeapObjects({reportProgress});
     return Boolean(response.getError());
   }
 
@@ -200,29 +200,29 @@ export interface CommonHeapProfile {
 }
 
 class HeapProfilerDispatcher implements ProtocolProxyApi.HeapProfilerDispatcher {
-  private readonly heapProfilerModel: HeapProfilerModel;
+  readonly #heapProfilerModel: HeapProfilerModel;
   constructor(model: HeapProfilerModel) {
-    this.heapProfilerModel = model;
+    this.#heapProfilerModel = model;
   }
 
   heapStatsUpdate({statsUpdate}: Protocol.HeapProfiler.HeapStatsUpdateEvent): void {
-    this.heapProfilerModel.heapStatsUpdate(statsUpdate);
+    this.#heapProfilerModel.heapStatsUpdate(statsUpdate);
   }
 
   lastSeenObjectId({lastSeenObjectId, timestamp}: Protocol.HeapProfiler.LastSeenObjectIdEvent): void {
-    this.heapProfilerModel.lastSeenObjectId(lastSeenObjectId, timestamp);
+    this.#heapProfilerModel.lastSeenObjectId(lastSeenObjectId, timestamp);
   }
 
   addHeapSnapshotChunk({chunk}: Protocol.HeapProfiler.AddHeapSnapshotChunkEvent): void {
-    this.heapProfilerModel.addHeapSnapshotChunk(chunk);
+    this.#heapProfilerModel.addHeapSnapshotChunk(chunk);
   }
 
   reportHeapSnapshotProgress({done, total, finished}: Protocol.HeapProfiler.ReportHeapSnapshotProgressEvent): void {
-    this.heapProfilerModel.reportHeapSnapshotProgress(done, total, finished);
+    this.#heapProfilerModel.reportHeapSnapshotProgress(done, total, finished);
   }
 
   resetProfiles(): void {
-    this.heapProfilerModel.resetProfiles();
+    this.#heapProfilerModel.resetProfiles();
   }
 }