chrome-devtools-frontend 1.0.1512349 → 1.0.1513662

package/front_end/core/sdk/IsolateManager.ts

@@ -12,7 +12,7 @@ let isolateManagerInstance: IsolateManager;
 
 export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<RuntimeModel> {
-  readonly #isolatesInternal = new Map<string, Isolate>();
+  readonly #isolates = new Map<string, Isolate>();
   /**
    * Contains null while the isolateId is being retrieved.
    */
@@ -44,16 +44,16 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
       void this.poll();
     }
     this.#observers.add(observer);
-    for (const isolate of this.#isolatesInternal.values()) {
+    for (const isolate of this.#isolates.values()) {
       observer.isolateAdded(isolate);
     }
   }
 
   modelAdded(model: RuntimeModel): void {
-    void this.modelAddedInternal(model);
+    void this.#modelAdded(model);
   }
 
-  private async modelAddedInternal(model: RuntimeModel): Promise<void> {
+  async #modelAdded(model: RuntimeModel): Promise<void> {
     this.#isolateIdByModel.set(model, null);
     const isolateId = await model.isolateId();
     if (!this.#isolateIdByModel.has(model)) {
@@ -65,13 +65,13 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
       return;
     }
     this.#isolateIdByModel.set(model, isolateId);
-    let isolate = this.#isolatesInternal.get(isolateId);
+    let isolate = this.#isolates.get(isolateId);
     if (!isolate) {
       isolate = new Isolate(isolateId);
-      this.#isolatesInternal.set(isolateId, isolate);
+      this.#isolates.set(isolateId, isolate);
     }
-    isolate.modelsInternal.add(model);
-    if (isolate.modelsInternal.size === 1) {
+    isolate.models().add(model);
+    if (isolate.models().size === 1) {
       for (const observer of this.#observers) {
         observer.isolateAdded(isolate);
       }
@@ -88,12 +88,12 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     if (!isolateId) {
       return;
     }
-    const isolate = this.#isolatesInternal.get(isolateId);
+    const isolate = this.#isolates.get(isolateId);
     if (!isolate) {
       return;
     }
-    isolate.modelsInternal.delete(model);
-    if (isolate.modelsInternal.size) {
+    isolate.models().delete(model);
+    if (isolate.models().size) {
       for (const observer of this.#observers) {
         observer.isolateChanged(isolate);
       }
@@ -102,15 +102,15 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     for (const observer of this.#observers) {
       observer.isolateRemoved(isolate);
     }
-    this.#isolatesInternal.delete(isolateId);
+    this.#isolates.delete(isolateId);
   }
 
   isolateByModel(model: RuntimeModel): Isolate|null {
-    return this.#isolatesInternal.get(this.#isolateIdByModel.get(model) || '') || null;
+    return this.#isolates.get(this.#isolateIdByModel.get(model) || '') || null;
   }
 
   isolates(): Iterable<Isolate> {
-    return this.#isolatesInternal.values();
+    return this.#isolates.values();
   }
 
   private async poll(): Promise<void> {
@@ -141,29 +141,29 @@ export const MemoryTrendWindowMs = 120e3;
 const PollIntervalMs = 2e3;
 
 export class Isolate {
-  readonly #idInternal: string;
-  readonly modelsInternal: Set<RuntimeModel>;
-  #usedHeapSizeInternal: number;
+  readonly #id: string;
+  readonly #models: Set<RuntimeModel>;
+  #usedHeapSize: number;
   readonly #memoryTrend: MemoryTrend;
 
   constructor(id: string) {
-    this.#idInternal = id;
-    this.modelsInternal = new Set();
-    this.#usedHeapSizeInternal = 0;
+    this.#id = id;
+    this.#models = new Set();
+    this.#usedHeapSize = 0;
     const count = MemoryTrendWindowMs / PollIntervalMs;
     this.#memoryTrend = new MemoryTrend(count);
   }
 
   id(): string {
-    return this.#idInternal;
+    return this.#id;
   }
 
   models(): Set<RuntimeModel> {
-    return this.modelsInternal;
+    return this.#models;
   }
 
   runtimeModel(): RuntimeModel|null {
-    return this.modelsInternal.values().next().value || null;
+    return this.#models.values().next().value || null;
   }
 
   heapProfilerModel(): HeapProfilerModel|null {
@@ -177,8 +177,8 @@ export class Isolate {
     if (!usage) {
       return;
     }
-    this.#usedHeapSizeInternal = usage.usedSize + (usage.embedderHeapUsedSize ?? 0) + (usage.backingStorageSize ?? 0);
-    this.#memoryTrend.add(this.#usedHeapSizeInternal);
+    this.#usedHeapSize = usage.usedSize + (usage.embedderHeapUsedSize ?? 0) + (usage.backingStorageSize ?? 0);
+    this.#memoryTrend.add(this.#usedHeapSize);
     IsolateManager.instance().dispatchEventToListeners(Events.MEMORY_CHANGED, this);
   }
 
@@ -187,7 +187,7 @@ export class Isolate {
   }
 
   usedHeapSize(): number {
-    return this.#usedHeapSizeInternal;
+    return this.#usedHeapSize;
   }
 
   /**

package/front_end/core/sdk/LayerTreeBase.ts

@@ -47,78 +47,77 @@ export namespace Layer {
 }
 
 export class StickyPositionConstraint {
-  readonly #stickyBoxRectInternal: Protocol.DOM.Rect;
-  readonly #containingBlockRectInternal: Protocol.DOM.Rect;
-  readonly #nearestLayerShiftingStickyBoxInternal: Layer|null;
-  readonly #nearestLayerShiftingContainingBlockInternal: Layer|null;
+  readonly #stickyBoxRect: Protocol.DOM.Rect;
+  readonly #containingBlockRect: Protocol.DOM.Rect;
+  readonly #nearestLayerShiftingStickyBox: Layer|null;
+  readonly #nearestLayerShiftingContainingBlock: Layer|null;
 
   constructor(layerTree: LayerTreeBase|null, constraint: Protocol.LayerTree.StickyPositionConstraint) {
-    this.#stickyBoxRectInternal = constraint.stickyBoxRect;
-    this.#containingBlockRectInternal = constraint.containingBlockRect;
-    this.#nearestLayerShiftingStickyBoxInternal = null;
+    this.#stickyBoxRect = constraint.stickyBoxRect;
+    this.#containingBlockRect = constraint.containingBlockRect;
+    this.#nearestLayerShiftingStickyBox = null;
     if (layerTree && constraint.nearestLayerShiftingStickyBox) {
-      this.#nearestLayerShiftingStickyBoxInternal = layerTree.layerById(constraint.nearestLayerShiftingStickyBox);
+      this.#nearestLayerShiftingStickyBox = layerTree.layerById(constraint.nearestLayerShiftingStickyBox);
     }
 
-    this.#nearestLayerShiftingContainingBlockInternal = null;
+    this.#nearestLayerShiftingContainingBlock = null;
     if (layerTree && constraint.nearestLayerShiftingContainingBlock) {
-      this.#nearestLayerShiftingContainingBlockInternal =
-          layerTree.layerById(constraint.nearestLayerShiftingContainingBlock);
+      this.#nearestLayerShiftingContainingBlock = layerTree.layerById(constraint.nearestLayerShiftingContainingBlock);
     }
   }
 
   stickyBoxRect(): Protocol.DOM.Rect {
-    return this.#stickyBoxRectInternal;
+    return this.#stickyBoxRect;
   }
 
   containingBlockRect(): Protocol.DOM.Rect {
-    return this.#containingBlockRectInternal;
+    return this.#containingBlockRect;
   }
 
   nearestLayerShiftingStickyBox(): Layer|null {
-    return this.#nearestLayerShiftingStickyBoxInternal;
+    return this.#nearestLayerShiftingStickyBox;
   }
 
   nearestLayerShiftingContainingBlock(): Layer|null {
-    return this.#nearestLayerShiftingContainingBlockInternal;
+    return this.#nearestLayerShiftingContainingBlock;
   }
 }
 
 export class LayerTreeBase {
-  readonly #targetInternal: Target|null;
+  readonly #target: Target|null;
   #domModel: DOMModel|null;
   layersById = new Map<string|number, Layer>();
-  #rootInternal: Layer|null = null;
-  #contentRootInternal: Layer|null = null;
-  readonly #backendNodeIdToNodeInternal = new Map<Protocol.DOM.BackendNodeId, DOMNode|null>();
-  #viewportSizeInternal?: {
+  #root: Layer|null = null;
+  #contentRoot: Layer|null = null;
+  readonly #backendNodeIdToNode = new Map<Protocol.DOM.BackendNodeId, DOMNode|null>();
+  #viewportSize?: {
     width: number,
     height: number,
   };
 
   constructor(target: Target|null) {
-    this.#targetInternal = target;
+    this.#target = target;
     this.#domModel = target ? target.model(DOMModel) : null;
   }
 
   target(): Target|null {
-    return this.#targetInternal;
+    return this.#target;
   }
 
   root(): Layer|null {
-    return this.#rootInternal;
+    return this.#root;
   }
 
   setRoot(root: Layer|null): void {
-    this.#rootInternal = root;
+    this.#root = root;
   }
 
   contentRoot(): Layer|null {
-    return this.#contentRootInternal;
+    return this.#contentRoot;
   }
 
   setContentRoot(contentRoot: Layer|null): void {
-    this.#contentRootInternal = contentRoot;
+    this.#contentRoot = contentRoot;
   }
 
   forEachLayer<T>(callback: (arg0: Layer) => T, root?: Layer|null): T|boolean {
@@ -146,25 +145,25 @@ export class LayerTreeBase {
       return;
     }
     for (const nodeId of nodesMap.keys()) {
-      this.#backendNodeIdToNodeInternal.set(nodeId, nodesMap.get(nodeId) || null);
+      this.#backendNodeIdToNode.set(nodeId, nodesMap.get(nodeId) || null);
     }
   }
 
   backendNodeIdToNode(): Map<Protocol.DOM.BackendNodeId, DOMNode|null> {
-    return this.#backendNodeIdToNodeInternal;
+    return this.#backendNodeIdToNode;
   }
 
   setViewportSize(viewportSize: {
     width: number,
     height: number,
   }): void {
-    this.#viewportSizeInternal = viewportSize;
+    this.#viewportSize = viewportSize;
   }
 
   viewportSize(): {
     width: number,
     height: number,
   }|undefined {
-    return this.#viewportSizeInternal;
+    return this.#viewportSize;
   }
 }

package/front_end/core/sdk/OverlayModel.ts

@@ -73,7 +73,7 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
   readonly #domModel: DOMModel;
   overlayAgent: ProtocolProxyApi.OverlayApi;
   readonly #debuggerModel: DebuggerModel|null;
-  #inspectModeEnabledInternal = false;
+  #inspectModeEnabled = false;
   #hideHighlightTimeout: number|null = null;
   #defaultHighlighter: Highlighter;
   #highlighter: Highlighter;
@@ -87,7 +87,7 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
   #showViewportSizeOnResize = true;
   #persistentHighlighter: OverlayPersistentHighlighter|null;
   readonly #sourceOrderHighlighter: SourceOrderHighlighter;
-  #sourceOrderModeActiveInternal = false;
+  #sourceOrderModeActive = false;
   #windowControls: WindowControls;
 
   constructor(target: Target) {
@@ -294,17 +294,17 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
   async setInspectMode(mode: Protocol.Overlay.InspectMode, showDetailedTooltip: boolean|undefined = true):
       Promise<void> {
     await this.#domModel.requestDocument();
-    this.#inspectModeEnabledInternal = mode !== Protocol.Overlay.InspectMode.None;
+    this.#inspectModeEnabled = mode !== Protocol.Overlay.InspectMode.None;
     this.dispatchEventToListeners(Events.INSPECT_MODE_WILL_BE_TOGGLED, this);
     void this.#highlighter.setInspectMode(mode, this.buildHighlightConfig('all', showDetailedTooltip));
   }
 
   inspectModeEnabled(): boolean {
-    return this.#inspectModeEnabledInternal;
+    return this.#inspectModeEnabled;
   }
 
   highlightInOverlay(data: HighlightData, mode?: string, showInfo?: boolean): void {
-    if (this.#sourceOrderModeActiveInternal) {
+    if (this.#sourceOrderModeActive) {
       // Return early if the source order is currently being shown the in the
       // overlay, so that it is not cleared by the highlight
       return;
@@ -460,7 +460,7 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
   }
 
   setSourceOrderActive(isActive: boolean): void {
-    this.#sourceOrderModeActiveInternal = isActive;
+    this.#sourceOrderModeActive = isActive;
   }
 
   private delayedHideHighlight(delay: number): void {

package/front_end/core/sdk/Resource.ts

@@ -40,17 +40,17 @@ import type {ResourceTreeFrame, ResourceTreeModel} from './ResourceTreeModel.js'
 
 export class Resource implements TextUtils.ContentProvider.ContentProvider {
   readonly #resourceTreeModel: ResourceTreeModel;
-  #requestInternal: NetworkRequest|null;
-  #urlInternal!: Platform.DevToolsPath.UrlString;
-  readonly #documentURLInternal: Platform.DevToolsPath.UrlString;
-  readonly #frameIdInternal: Protocol.Page.FrameId|null;
-  readonly #loaderIdInternal: Protocol.Network.LoaderId|null;
+  #request: NetworkRequest|null;
+  #url!: Platform.DevToolsPath.UrlString;
+  readonly #documentURL: Platform.DevToolsPath.UrlString;
+  readonly #frameId: Protocol.Page.FrameId|null;
+  readonly #loaderId: Protocol.Network.LoaderId|null;
   readonly #type: Common.ResourceType.ResourceType;
-  #mimeTypeInternal: string;
-  #isGeneratedInternal: boolean;
-  #lastModifiedInternal: Date|null;
-  readonly #contentSizeInternal: number|null;
-  #parsedURLInternal?: Common.ParsedURL.ParsedURL;
+  #mimeType: string;
+  #isGenerated: boolean;
+  #lastModified: Date|null;
+  readonly #contentSize: number|null;
+  #parsedURL?: Common.ParsedURL.ParsedURL;
   #contentData: TextUtils.ContentData.ContentData|null = null;
   /**
    * There is always at most one CDP "getResourceContent" call in-flight. But once it's done
@@ -64,76 +64,76 @@ export class Resource implements TextUtils.ContentProvider.ContentProvider {
       loaderId: Protocol.Network.LoaderId|null, type: Common.ResourceType.ResourceType, mimeType: string,
       lastModified: Date|null, contentSize: number|null) {
     this.#resourceTreeModel = resourceTreeModel;
-    this.#requestInternal = request;
+    this.#request = request;
     this.url = url;
 
-    this.#documentURLInternal = documentURL;
-    this.#frameIdInternal = frameId;
-    this.#loaderIdInternal = loaderId;
+    this.#documentURL = documentURL;
+    this.#frameId = frameId;
+    this.#loaderId = loaderId;
     this.#type = type || Common.ResourceType.resourceTypes.Other;
-    this.#mimeTypeInternal = mimeType;
-    this.#isGeneratedInternal = false;
+    this.#mimeType = mimeType;
+    this.#isGenerated = false;
 
-    this.#lastModifiedInternal = lastModified && Platform.DateUtilities.isValid(lastModified) ? lastModified : null;
-    this.#contentSizeInternal = contentSize;
+    this.#lastModified = lastModified && Platform.DateUtilities.isValid(lastModified) ? lastModified : null;
+    this.#contentSize = contentSize;
   }
 
   lastModified(): Date|null {
-    if (this.#lastModifiedInternal || !this.#requestInternal) {
-      return this.#lastModifiedInternal;
+    if (this.#lastModified || !this.#request) {
+      return this.#lastModified;
     }
-    const lastModifiedHeader = this.#requestInternal.responseLastModified();
+    const lastModifiedHeader = this.#request.responseLastModified();
     const date = lastModifiedHeader ? new Date(lastModifiedHeader) : null;
-    this.#lastModifiedInternal = date && Platform.DateUtilities.isValid(date) ? date : null;
-    return this.#lastModifiedInternal;
+    this.#lastModified = date && Platform.DateUtilities.isValid(date) ? date : null;
+    return this.#lastModified;
   }
 
   contentSize(): number|null {
-    if (typeof this.#contentSizeInternal === 'number' || !this.#requestInternal) {
-      return this.#contentSizeInternal;
+    if (typeof this.#contentSize === 'number' || !this.#request) {
+      return this.#contentSize;
     }
-    return this.#requestInternal.resourceSize;
+    return this.#request.resourceSize;
   }
 
   get request(): NetworkRequest|null {
-    return this.#requestInternal;
+    return this.#request;
   }
 
   get url(): Platform.DevToolsPath.UrlString {
-    return this.#urlInternal;
+    return this.#url;
   }
 
   set url(x: Platform.DevToolsPath.UrlString) {
-    this.#urlInternal = x;
-    this.#parsedURLInternal = new Common.ParsedURL.ParsedURL(x);
+    this.#url = x;
+    this.#parsedURL = new Common.ParsedURL.ParsedURL(x);
   }
 
   get parsedURL(): Common.ParsedURL.ParsedURL|undefined {
-    return this.#parsedURLInternal;
+    return this.#parsedURL;
   }
 
   get documentURL(): Platform.DevToolsPath.UrlString {
-    return this.#documentURLInternal;
+    return this.#documentURL;
   }
 
   get frameId(): Protocol.Page.FrameId|null {
-    return this.#frameIdInternal;
+    return this.#frameId;
   }
 
   get loaderId(): Protocol.Network.LoaderId|null {
-    return this.#loaderIdInternal;
+    return this.#loaderId;
   }
 
   get displayName(): string {
-    return this.#parsedURLInternal ? this.#parsedURLInternal.displayName : '';
+    return this.#parsedURL ? this.#parsedURL.displayName : '';
   }
 
   resourceType(): Common.ResourceType.ResourceType {
-    return this.#requestInternal ? this.#requestInternal.resourceType() : this.#type;
+    return this.#request ? this.#request.resourceType() : this.#type;
   }
 
   get mimeType(): string {
-    return this.#requestInternal ? this.#requestInternal.mimeType : this.#mimeTypeInternal;
+    return this.#request ? this.#request.mimeType : this.#mimeType;
   }
 
   get content(): string|null {
@@ -144,15 +144,15 @@ export class Resource implements TextUtils.ContentProvider.ContentProvider {
   }
 
   get isGenerated(): boolean {
-    return this.#isGeneratedInternal;
+    return this.#isGenerated;
   }
 
   set isGenerated(val: boolean) {
-    this.#isGeneratedInternal = val;
+    this.#isGenerated = val;
   }
 
   contentURL(): Platform.DevToolsPath.UrlString {
-    return this.#urlInternal;
+    return this.#url;
   }
 
   contentType(): Common.ResourceType.ResourceType {
@@ -204,7 +204,7 @@ export class Resource implements TextUtils.ContentProvider.ContentProvider {
     if (TextUtils.ContentData.ContentData.isError(contentData)) {
       return;
     }
-    image.src = contentData.asDataUrl() ?? this.#urlInternal;
+    image.src = contentData.asDataUrl() ?? this.#url;
   }
 
   private async innerRequestContent(): Promise<TextUtils.ContentData.ContentDataOrError> {
@@ -223,10 +223,10 @@ export class Resource implements TextUtils.ContentProvider.ContentProvider {
   }
 
   frame(): ResourceTreeFrame|null {
-    return this.#frameIdInternal ? this.#resourceTreeModel.frameForId(this.#frameIdInternal) : null;
+    return this.#frameId ? this.#resourceTreeModel.frameForId(this.#frameId) : null;
   }
 
   statusCode(): number {
-    return this.#requestInternal ? this.#requestInternal.statusCode : 0;
+    return this.#request ? this.#request.statusCode : 0;
   }
 }