chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/ChildTargetManager.ts

@@ -15,34 +15,34 @@ import {SDKModel} from './SDKModel.js';
 import {Events as TargetManagerEvents, TargetManager} from './TargetManager.js';
 
 export class ChildTargetManager extends SDKModel<EventTypes> implements ProtocolProxyApi.TargetDispatcher {
-  private readonly targetManager: TargetManager;
-  private parentTarget: Target;
-  private readonly targetAgent: ProtocolProxyApi.TargetApi;
-  private readonly targetInfosInternal: Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo> = new Map();
-  private readonly childTargetsBySessionId: Map<Protocol.Target.SessionID, Target> = new Map();
-  private readonly childTargetsById: Map<Protocol.Target.TargetID|'main', Target> = new Map();
-  private readonly parallelConnections: Map<string, ProtocolClient.InspectorBackend.Connection> = new Map();
-  private parentTargetId: Protocol.Target.TargetID|null = null;
+  readonly #targetManager: TargetManager;
+  #parentTarget: Target;
+  readonly #targetAgent: ProtocolProxyApi.TargetApi;
+  readonly #targetInfosInternal: Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo> = new Map();
+  readonly #childTargetsBySessionId: Map<Protocol.Target.SessionID, Target> = new Map();
+  readonly #childTargetsById: Map<Protocol.Target.TargetID|'main', Target> = new Map();
+  readonly #parallelConnections: Map<string, ProtocolClient.InspectorBackend.Connection> = new Map();
+  #parentTargetId: Protocol.Target.TargetID|null = null;
 
   constructor(parentTarget: Target) {
     super(parentTarget);
-    this.targetManager = parentTarget.targetManager();
-    this.parentTarget = parentTarget;
-    this.targetAgent = parentTarget.targetAgent();
+    this.#targetManager = parentTarget.targetManager();
+    this.#parentTarget = parentTarget;
+    this.#targetAgent = parentTarget.targetAgent();
     parentTarget.registerTargetDispatcher(this);
-    const browserTarget = this.targetManager.browserTarget();
+    const browserTarget = this.#targetManager.browserTarget();
     if (browserTarget) {
       if (browserTarget !== parentTarget) {
         browserTarget.targetAgent().invoke_autoAttachRelated(
             {targetId: parentTarget.id() as Protocol.Target.TargetID, waitForDebuggerOnStart: true});
       }
     } else {
-      this.targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
+      this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
     }
 
     if (!parentTarget.parentTarget() && !Host.InspectorFrontendHost.isUnderTest()) {
-      this.targetAgent.invoke_setDiscoverTargets({discover: true});
-      this.targetAgent.invoke_setRemoteLocations({locations: [{host: 'localhost', port: 9229}]});
+      this.#targetAgent.invoke_setDiscoverTargets({discover: true});
+      this.#targetAgent.invoke_setRemoteLocations({locations: [{host: 'localhost', port: 9229}]});
     }
   }
 
@@ -55,32 +55,32 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   childTargets(): Target[] {
-    return Array.from(this.childTargetsBySessionId.values());
+    return Array.from(this.#childTargetsBySessionId.values());
   }
 
   async suspendModel(): Promise<void> {
-    await this.targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: false, flatten: true});
+    await this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: false, flatten: true});
   }
 
   async resumeModel(): Promise<void> {
-    await this.targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
+    await this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
   }
 
   dispose(): void {
-    for (const sessionId of this.childTargetsBySessionId.keys()) {
+    for (const sessionId of this.#childTargetsBySessionId.keys()) {
       this.detachedFromTarget({sessionId, targetId: undefined});
     }
   }
 
   targetCreated({targetInfo}: Protocol.Target.TargetCreatedEvent): void {
-    this.targetInfosInternal.set(targetInfo.targetId, targetInfo);
+    this.#targetInfosInternal.set(targetInfo.targetId, targetInfo);
     this.fireAvailableTargetsChanged();
     this.dispatchEventToListeners(Events.TargetCreated, targetInfo);
   }
 
   targetInfoChanged({targetInfo}: Protocol.Target.TargetInfoChangedEvent): void {
-    this.targetInfosInternal.set(targetInfo.targetId, targetInfo);
-    const target = this.childTargetsById.get(targetInfo.targetId);
+    this.#targetInfosInternal.set(targetInfo.targetId, targetInfo);
+    const target = this.#childTargetsById.get(targetInfo.targetId);
     if (target) {
       target.updateTargetInfo(targetInfo);
     }
@@ -89,7 +89,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   targetDestroyed({targetId}: Protocol.Target.TargetDestroyedEvent): void {
-    this.targetInfosInternal.delete(targetId);
+    this.#targetInfosInternal.delete(targetId);
     this.fireAvailableTargetsChanged();
     this.dispatchEventToListeners(Events.TargetDestroyed, targetId);
   }
@@ -100,19 +100,19 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
 
   private fireAvailableTargetsChanged(): void {
     TargetManager.instance().dispatchEventToListeners(
-        TargetManagerEvents.AvailableTargetsChanged, [...this.targetInfosInternal.values()]);
+        TargetManagerEvents.AvailableTargetsChanged, [...this.#targetInfosInternal.values()]);
   }
 
   async getParentTargetId(): Promise<Protocol.Target.TargetID> {
-    if (!this.parentTargetId) {
-      this.parentTargetId = (await this.parentTarget.targetAgent().invoke_getTargetInfo({})).targetInfo.targetId;
+    if (!this.#parentTargetId) {
+      this.#parentTargetId = (await this.#parentTarget.targetAgent().invoke_getTargetInfo({})).targetInfo.targetId;
     }
-    return this.parentTargetId;
+    return this.#parentTargetId;
   }
 
   async attachedToTarget({sessionId, targetInfo, waitingForDebugger}: Protocol.Target.AttachedToTargetEvent):
       Promise<void> {
-    if (this.parentTargetId === targetInfo.targetId) {
+    if (this.#parentTargetId === targetInfo.targetId) {
       return;
     }
     let targetName = '';
@@ -139,10 +139,10 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
       type = Type.ServiceWorker;
     }
 
-    const target = this.targetManager.createTarget(
-        targetInfo.targetId, targetName, type, this.parentTarget, sessionId, undefined, undefined, targetInfo);
-    this.childTargetsBySessionId.set(sessionId, target);
-    this.childTargetsById.set(target.id(), target);
+    const target = this.#targetManager.createTarget(
+        targetInfo.targetId, targetName, type, this.#parentTarget, sessionId, undefined, undefined, targetInfo);
+    this.#childTargetsBySessionId.set(sessionId, target);
+    this.#childTargetsById.set(target.id(), target);
 
     if (ChildTargetManager.attachCallback) {
       await ChildTargetManager.attachCallback({target, waitingForDebugger});
@@ -151,14 +151,14 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   detachedFromTarget({sessionId}: Protocol.Target.DetachedFromTargetEvent): void {
-    if (this.parallelConnections.has(sessionId)) {
-      this.parallelConnections.delete(sessionId);
+    if (this.#parallelConnections.has(sessionId)) {
+      this.#parallelConnections.delete(sessionId);
     } else {
-      const target = this.childTargetsBySessionId.get(sessionId);
+      const target = this.#childTargetsBySessionId.get(sessionId);
       if (target) {
         target.dispose('target terminated');
-        this.childTargetsBySessionId.delete(sessionId);
-        this.childTargetsById.delete(target.id());
+        this.#childTargetsBySessionId.delete(sessionId);
+        this.#childTargetsById.delete(target.id());
       }
     }
   }
@@ -172,9 +172,10 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
     // The main Target id is actually just `main`, instead of the real targetId.
     // Get the real id (requires an async operation) so that it can be used synchronously later.
     const targetId = await this.getParentTargetId();
-    const {connection, sessionId} = await this.createParallelConnectionAndSessionForTarget(this.parentTarget, targetId);
+    const {connection, sessionId} =
+        await this.createParallelConnectionAndSessionForTarget(this.#parentTarget, targetId);
     connection.setOnMessage(onMessage);
-    this.parallelConnections.set(sessionId, connection);
+    this.#parallelConnections.set(sessionId, connection);
     return connection;
   }
 
@@ -196,7 +197,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   targetInfos(): Protocol.Target.TargetInfo[] {
-    return Array.from(this.targetInfosInternal.values());
+    return Array.from(this.#targetInfosInternal.values());
   }
 
   private static lastAnonymousTargetId = 0;

package/front_end/core/sdk/CompilerSourceMappingContentProvider.ts

@@ -48,22 +48,22 @@ const str_ = i18n.i18n.registerUIStrings('core/sdk/CompilerSourceMappingContentP
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class CompilerSourceMappingContentProvider implements TextUtils.ContentProvider.ContentProvider {
-  private readonly sourceURL: string;
-  private readonly contentTypeInternal: Common.ResourceType.ResourceType;
-  private readonly initiator: PageResourceLoadInitiator;
+  readonly #sourceURL: string;
+  readonly #contentTypeInternal: Common.ResourceType.ResourceType;
+  readonly #initiator: PageResourceLoadInitiator;
 
   constructor(sourceURL: string, contentType: Common.ResourceType.ResourceType, initiator: PageResourceLoadInitiator) {
-    this.sourceURL = sourceURL;
-    this.contentTypeInternal = contentType;
-    this.initiator = initiator;
+    this.#sourceURL = sourceURL;
+    this.#contentTypeInternal = contentType;
+    this.#initiator = initiator;
   }
 
   contentURL(): string {
-    return this.sourceURL;
+    return this.#sourceURL;
   }
 
   contentType(): Common.ResourceType.ResourceType {
-    return this.contentTypeInternal;
+    return this.#contentTypeInternal;
   }
 
   async contentEncoded(): Promise<boolean> {
@@ -72,10 +72,10 @@ export class CompilerSourceMappingContentProvider implements TextUtils.ContentPr
 
   async requestContent(): Promise<TextUtils.ContentProvider.DeferredContent> {
     try {
-      const {content} = await PageResourceLoader.instance().loadResource(this.sourceURL, this.initiator);
+      const {content} = await PageResourceLoader.instance().loadResource(this.#sourceURL, this.#initiator);
       return {content, isEncoded: false};
     } catch (e) {
-      const error = i18nString(UIStrings.couldNotLoadContentForSS, {PH1: this.sourceURL, PH2: e.message});
+      const error = i18nString(UIStrings.couldNotLoadContentForSS, {PH1: this.#sourceURL, PH2: e.message});
       console.error(error);
       return {content: null, error, isEncoded: false};
     }

package/front_end/core/sdk/Connections.ts

@@ -11,16 +11,16 @@ import {TargetManager} from './TargetManager.js';
 
 export class MainConnection implements ProtocolClient.InspectorBackend.Connection {
   onMessage: ((arg0: (Object|string)) => void)|null;
-  private onDisconnect: ((arg0: string) => void)|null;
-  private messageBuffer: string;
-  private messageSize: number;
-  private readonly eventListeners: Common.EventTarget.EventDescriptor[];
+  #onDisconnect: ((arg0: string) => void)|null;
+  #messageBuffer: string;
+  #messageSize: number;
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
   constructor() {
     this.onMessage = null;
-    this.onDisconnect = null;
-    this.messageBuffer = '';
-    this.messageSize = 0;
-    this.eventListeners = [
+    this.#onDisconnect = null;
+    this.#messageBuffer = '';
+    this.#messageSize = 0;
+    this.#eventListeners = [
       Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
           Host.InspectorFrontendHostAPI.Events.DispatchMessage, this.dispatchMessage, this),
       Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
@@ -33,7 +33,7 @@ export class MainConnection implements ProtocolClient.InspectorBackend.Connectio
   }
 
   setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.onDisconnect = onDisconnect;
+    this.#onDisconnect = onDisconnect;
   }
 
   sendRawMessage(message: string): void {
@@ -52,21 +52,21 @@ export class MainConnection implements ProtocolClient.InspectorBackend.Connectio
       event: Common.EventTarget.EventTargetEvent<Host.InspectorFrontendHostAPI.DispatchMessageChunkEvent>): void {
     const {messageChunk, messageSize} = event.data;
     if (messageSize) {
-      this.messageBuffer = '';
-      this.messageSize = messageSize;
+      this.#messageBuffer = '';
+      this.#messageSize = messageSize;
     }
-    this.messageBuffer += messageChunk;
-    if (this.messageBuffer.length === this.messageSize && this.onMessage) {
-      this.onMessage.call(null, this.messageBuffer);
-      this.messageBuffer = '';
-      this.messageSize = 0;
+    this.#messageBuffer += messageChunk;
+    if (this.#messageBuffer.length === this.#messageSize && this.onMessage) {
+      this.onMessage.call(null, this.#messageBuffer);
+      this.#messageBuffer = '';
+      this.#messageSize = 0;
     }
   }
 
   async disconnect(): Promise<void> {
-    const onDisconnect = this.onDisconnect;
-    Common.EventTarget.removeEventListeners(this.eventListeners);
-    this.onDisconnect = null;
+    const onDisconnect = this.#onDisconnect;
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+    this.#onDisconnect = null;
     this.onMessage = null;
 
     if (onDisconnect) {
@@ -76,28 +76,28 @@ export class MainConnection implements ProtocolClient.InspectorBackend.Connectio
 }
 
 export class WebSocketConnection implements ProtocolClient.InspectorBackend.Connection {
-  private socket: WebSocket|null;
+  #socket: WebSocket|null;
   onMessage: ((arg0: (Object|string)) => void)|null;
-  private onDisconnect: ((arg0: string) => void)|null;
-  private onWebSocketDisconnect: (() => void)|null;
-  private connected: boolean;
-  private messages: string[];
+  #onDisconnect: ((arg0: string) => void)|null;
+  #onWebSocketDisconnect: (() => void)|null;
+  #connected: boolean;
+  #messages: string[];
   constructor(url: string, onWebSocketDisconnect: () => void) {
-    this.socket = new WebSocket(url);
-    this.socket.onerror = this.onError.bind(this);
-    this.socket.onopen = this.onOpen.bind(this);
-    this.socket.onmessage = (messageEvent: MessageEvent<string>): void => {
+    this.#socket = new WebSocket(url);
+    this.#socket.onerror = this.onError.bind(this);
+    this.#socket.onopen = this.onOpen.bind(this);
+    this.#socket.onmessage = (messageEvent: MessageEvent<string>): void => {
       if (this.onMessage) {
         this.onMessage.call(null, messageEvent.data);
       }
     };
-    this.socket.onclose = this.onClose.bind(this);
+    this.#socket.onclose = this.onClose.bind(this);
 
     this.onMessage = null;
-    this.onDisconnect = null;
-    this.onWebSocketDisconnect = onWebSocketDisconnect;
-    this.connected = false;
-    this.messages = [];
+    this.#onDisconnect = null;
+    this.#onWebSocketDisconnect = onWebSocketDisconnect;
+    this.#connected = false;
+    this.#messages = [];
   }
 
   setOnMessage(onMessage: (arg0: (Object|string)) => void): void {
@@ -105,66 +105,66 @@ export class WebSocketConnection implements ProtocolClient.InspectorBackend.Conn
   }
 
   setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.onDisconnect = onDisconnect;
+    this.#onDisconnect = onDisconnect;
   }
 
   private onError(): void {
-    if (this.onWebSocketDisconnect) {
-      this.onWebSocketDisconnect.call(null);
+    if (this.#onWebSocketDisconnect) {
+      this.#onWebSocketDisconnect.call(null);
     }
-    if (this.onDisconnect) {
+    if (this.#onDisconnect) {
       // This is called if error occurred while connecting.
-      this.onDisconnect.call(null, 'connection failed');
+      this.#onDisconnect.call(null, 'connection failed');
     }
     this.close();
   }
 
   private onOpen(): void {
-    this.connected = true;
-    if (this.socket) {
-      this.socket.onerror = console.error;
-      for (const message of this.messages) {
-        this.socket.send(message);
+    this.#connected = true;
+    if (this.#socket) {
+      this.#socket.onerror = console.error;
+      for (const message of this.#messages) {
+        this.#socket.send(message);
       }
     }
-    this.messages = [];
+    this.#messages = [];
   }
 
   private onClose(): void {
-    if (this.onWebSocketDisconnect) {
-      this.onWebSocketDisconnect.call(null);
+    if (this.#onWebSocketDisconnect) {
+      this.#onWebSocketDisconnect.call(null);
     }
-    if (this.onDisconnect) {
-      this.onDisconnect.call(null, 'websocket closed');
+    if (this.#onDisconnect) {
+      this.#onDisconnect.call(null, 'websocket closed');
     }
     this.close();
   }
 
   private close(callback?: (() => void)): void {
-    if (this.socket) {
-      this.socket.onerror = null;
-      this.socket.onopen = null;
-      this.socket.onclose = callback || null;
-      this.socket.onmessage = null;
-      this.socket.close();
-      this.socket = null;
+    if (this.#socket) {
+      this.#socket.onerror = null;
+      this.#socket.onopen = null;
+      this.#socket.onclose = callback || null;
+      this.#socket.onmessage = null;
+      this.#socket.close();
+      this.#socket = null;
     }
-    this.onWebSocketDisconnect = null;
+    this.#onWebSocketDisconnect = null;
   }
 
   sendRawMessage(message: string): void {
-    if (this.connected && this.socket) {
-      this.socket.send(message);
+    if (this.#connected && this.#socket) {
+      this.#socket.send(message);
     } else {
-      this.messages.push(message);
+      this.#messages.push(message);
     }
   }
 
   disconnect(): Promise<void> {
     return new Promise(fulfill => {
       this.close(() => {
-        if (this.onDisconnect) {
-          this.onDisconnect.call(null, 'force disconnect');
+        if (this.#onDisconnect) {
+          this.#onDisconnect.call(null, 'force disconnect');
         }
         fulfill();
       });
@@ -174,10 +174,10 @@ export class WebSocketConnection implements ProtocolClient.InspectorBackend.Conn
 
 export class StubConnection implements ProtocolClient.InspectorBackend.Connection {
   onMessage: ((arg0: (Object|string)) => void)|null;
-  private onDisconnect: ((arg0: string) => void)|null;
+  #onDisconnect: ((arg0: string) => void)|null;
   constructor() {
     this.onMessage = null;
-    this.onDisconnect = null;
+    this.#onDisconnect = null;
   }
 
   setOnMessage(onMessage: (arg0: (Object|string)) => void): void {
@@ -185,7 +185,7 @@ export class StubConnection implements ProtocolClient.InspectorBackend.Connectio
   }
 
   setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.onDisconnect = onDisconnect;
+    this.#onDisconnect = onDisconnect;
   }
 
   sendRawMessage(message: string): void {
@@ -205,24 +205,24 @@ export class StubConnection implements ProtocolClient.InspectorBackend.Connectio
   }
 
   async disconnect(): Promise<void> {
-    if (this.onDisconnect) {
-      this.onDisconnect.call(null, 'force disconnect');
+    if (this.#onDisconnect) {
+      this.#onDisconnect.call(null, 'force disconnect');
     }
-    this.onDisconnect = null;
+    this.#onDisconnect = null;
     this.onMessage = null;
   }
 }
 
 export class ParallelConnection implements ProtocolClient.InspectorBackend.Connection {
-  private readonly connection: ProtocolClient.InspectorBackend.Connection;
-  private sessionId: string;
+  readonly #connection: ProtocolClient.InspectorBackend.Connection;
+  #sessionId: string;
   onMessage: ((arg0: Object) => void)|null;
-  private onDisconnect: ((arg0: string) => void)|null;
+  #onDisconnect: ((arg0: string) => void)|null;
   constructor(connection: ProtocolClient.InspectorBackend.Connection, sessionId: string) {
-    this.connection = connection;
-    this.sessionId = sessionId;
+    this.#connection = connection;
+    this.#sessionId = sessionId;
     this.onMessage = null;
-    this.onDisconnect = null;
+    this.#onDisconnect = null;
   }
 
   setOnMessage(onMessage: (arg0: Object) => void): void {
@@ -230,31 +230,31 @@ export class ParallelConnection implements ProtocolClient.InspectorBackend.Conne
   }
 
   setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.onDisconnect = onDisconnect;
+    this.#onDisconnect = onDisconnect;
   }
 
   getOnDisconnect(): ((arg0: string) => void)|null {
-    return this.onDisconnect;
+    return this.#onDisconnect;
   }
 
   sendRawMessage(message: string): void {
     const messageObject = JSON.parse(message);
     // If the message isn't for a specific session, it must be for the root session.
     if (!messageObject.sessionId) {
-      messageObject.sessionId = this.sessionId;
+      messageObject.sessionId = this.#sessionId;
     }
-    this.connection.sendRawMessage(JSON.stringify(messageObject));
+    this.#connection.sendRawMessage(JSON.stringify(messageObject));
   }
 
   getSessionId(): string {
-    return this.sessionId;
+    return this.#sessionId;
   }
 
   async disconnect(): Promise<void> {
-    if (this.onDisconnect) {
-      this.onDisconnect.call(null, 'force disconnect');
+    if (this.#onDisconnect) {
+      this.#onDisconnect.call(null, 'force disconnect');
     }
-    this.onDisconnect = null;
+    this.#onDisconnect = null;
     this.onMessage = null;
   }
 }