chrome-devtools-frontend 1.0.1538310 → 1.0.1539728

package/eslint.config.mjs

@@ -30,7 +30,7 @@ export default defineConfig([
     // All of these scripts are auto-generated so don't lint them.
     'front_end/generated/ARIAProperties.js',
     'front_end/generated/Deprecation.ts',
-    'front_end/generated/InspectorBackendCommands.js',
+    'front_end/generated/InspectorBackendCommands.ts',
     'front_end/generated/protocol-mapping.d.ts',
     'front_end/generated/protocol-proxy-api.d.ts',
     'front_end/generated/protocol.ts',

package/front_end/core/protocol_client/CDPConnection.ts

@@ -4,26 +4,28 @@
 
 import type {ProtocolMapping} from '../../generated/protocol-mapping.js';
 
+export type Command = keyof ProtocolMapping.Commands;
 export type CommandParams<T extends keyof ProtocolMapping.Commands> = ProtocolMapping.Commands[T]['paramsType'][0];
 export type CommandResult<T extends keyof ProtocolMapping.Commands> = ProtocolMapping.Commands[T]['returnType'];
+export type Event = keyof ProtocolMapping.Events;
 export type EventParams<T extends keyof ProtocolMapping.Events> = ProtocolMapping.Events[T];
 
 export interface CDPBaseMessage {
   sessionId?: string;
 }
 
-export interface CDPCommandRequest<T extends keyof ProtocolMapping.Commands> extends CDPBaseMessage {
+export interface CDPCommandRequest<T extends Command> extends CDPBaseMessage {
   id: number;
   method: T;
   params: CommandParams<T>;
 }
 
-export interface CDPCommandResponse<T extends keyof ProtocolMapping.Commands> extends CDPBaseMessage {
+export interface CDPCommandResponse<T extends Command> extends CDPBaseMessage {
   id: number;
   result: CommandResult<T>;
 }
 
-export interface CDPEvent<T extends keyof ProtocolMapping.Events> extends CDPBaseMessage {
+export interface CDPEvent<T extends Event> extends CDPBaseMessage {
   method: T;
   params: EventParams<T>;
 }
@@ -31,7 +33,7 @@ export interface CDPEvent<T extends keyof ProtocolMapping.Events> extends CDPBas
 /**
  * Keep this in sync with https://source.chromium.org/chromium/chromium/src/+/main:third_party/inspector_protocol/crdtp/dispatch.h.
  */
-export const enum CDPErrorStatus {
+export enum CDPErrorStatus {
   PARSE_ERROR = -32700,
   INVALID_REQUEST = -32600,
   METHOD_NOT_FOUND = -32601,
@@ -39,6 +41,7 @@ export const enum CDPErrorStatus {
   INTERNAL_ERROR = -32603,
   SERVER_ERROR = -32000,
   SESSION_NOT_FOUND = SERVER_ERROR - 1,
+  DEVTOOLS_STUB_ERROR = -32015,
 }
 
 export interface CDPError {
@@ -52,8 +55,7 @@ export interface CDPErrorMessage extends CDPBaseMessage {
   error: CDPError;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type CDPMessage = CDPCommandRequest<any>|CDPCommandResponse<any>|CDPEvent<any>|CDPErrorMessage;
+export type CDPReceivableMessage = CDPCommandResponse<Command>|CDPEvent<Event>|CDPErrorMessage;
 
 /**
  * Allows the sending and receiving of CDP commands and the notification of CDP events to observers.
@@ -63,7 +65,7 @@ export type CDPMessage = CDPCommandRequest<any>|CDPCommandResponse<any>|CDPEvent
  * would conflict with any other shared traffic.
  */
 export interface CDPConnection {
-  send<T extends keyof ProtocolMapping.Commands>(method: T, params: CommandParams<T>, sessionId: string|undefined):
+  send<T extends Command>(method: T, params: CommandParams<T>, sessionId: string|undefined):
       Promise<{result: CommandResult<T>}|{error: CDPError}>;
 
   observe(observer: CDPConnectionObserver): void;
@@ -71,7 +73,7 @@ export interface CDPConnection {
 }
 
 export interface CDPConnectionObserver {
-  onEvent<T extends keyof ProtocolMapping.Events>(event: ProtocolMapping.Events[T]): void;
+  onEvent<T extends Event>(event: CDPEvent<T>): void;
   onDisconnect(reason: string): void;
 }
 
@@ -84,6 +86,6 @@ export interface DebuggableCDPConnection extends CDPConnection {
 }
 
 export interface RawMessageObserver {
-  onMessageReceived(message: CDPMessage): void;
-  onMessageSent(message: CDPMessage): void;
+  onMessageReceived(message: CDPReceivableMessage): void;
+  onMessageSent(message: CDPCommandRequest<Command>): void;
 }

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -7,15 +7,20 @@ import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 import type * as Platform from '../platform/platform.js';
 
+import {
+  type CDPCommandRequest,
+  type CDPConnection,
+  type CDPConnectionObserver,
+  type CDPError,
+  CDPErrorStatus,
+  type CDPReceivableMessage,
+  type Command,
+  type CommandParams,
+  type CommandResult
+} from './CDPConnection.js';
 import {ConnectionTransport} from './ConnectionTransport.js';
 import {NodeURL} from './NodeURL.js';
 
-export const DevToolsStubErrorCode = -32015;
-// TODO(dgozman): we are not reporting generic errors in tests, but we should
-// instead report them and just have some expected errors in test expectations.
-const GenericErrorCode = -32000;
-const ConnectionClosedErrorCode = -32001;
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MessageParams = Record<string, any>;
 
@@ -59,25 +64,17 @@ export const qualifyName = (domain: string, name: UnqualifiedName): QualifiedNam
 type EventParameterNames = Map<QualifiedName, string[]>;
 type ReadonlyEventParameterNames = ReadonlyMap<QualifiedName, string[]>;
 
-interface CommandParameter {
-  name: string;
-  type: string;
-  optional: boolean;
-  description: string;
-}
+type CommandParameter = InspectorBackendCommands.CommandParameter;
 
 type Callback = (error: MessageError|null, arg1: Object|null) => void;
-interface ResponseWithError {
-  error: MessageError|null;
-  result: Object|null;
-}
 
 interface CallbackWithDebugInfo {
-  resolve: (response: ResponseWithError) => void;
+  resolve: (response: Awaited<ReturnType<CDPConnection['send']>>) => void;
   method: string;
+  sessionId: string|undefined;
 }
 
-export class InspectorBackend {
+export class InspectorBackend implements InspectorBackendCommands.InspectorBackendAPI {
   readonly agentPrototypes = new Map<ProtocolDomainName, AgentPrototype>();
   #eventParameterNamesForDomain = new Map<ProtocolDomainName, EventParameterNames>();
   readonly typeMap = new Map<QualifiedName, CommandParameter[]>();
@@ -197,17 +194,17 @@ export const test = {
 
 const LongPollingMethods = new Set<string>(['CSS.takeComputedStyleUpdates']);
 
-export class SessionRouter {
+export class SessionRouter implements CDPConnection {
   readonly #connection: ConnectionTransport;
   #lastMessageId = 1;
   #pendingResponsesCount = 0;
   readonly #pendingLongPollingMessageIds = new Set<number>();
   readonly #sessions = new Map<string, {
     target: TargetBase,
-    callbacks: Map<number, CallbackWithDebugInfo>,
-    proxyConnection: ConnectionTransport|undefined|null,
   }>();
   #pendingScripts: Array<() => void> = [];
+  readonly #callbacks = new Map<number, CallbackWithDebugInfo>();
+  readonly #observers = new Set<CDPConnectionObserver>();
 
   constructor(connection: ConnectionTransport) {
     this.#connection = connection;
@@ -222,22 +219,20 @@ export class SessionRouter {
       if (session) {
         session.target.dispose(reason);
       }
+      this.#observers.forEach(observer => observer.onDisconnect(reason));
     });
   }
 
-  registerSession(target: TargetBase, sessionId: string, proxyConnection?: ConnectionTransport|null): void {
-    // Only the Audits panel uses proxy connections. If it is ever possible to have multiple active at the
-    // same time, it should be tested thoroughly.
-    if (proxyConnection) {
-      for (const session of this.#sessions.values()) {
-        if (session.proxyConnection) {
-          console.error('Multiple simultaneous proxy connections are currently unsupported');
-          break;
-        }
-      }
-    }
+  observe(observer: CDPConnectionObserver): void {
+    this.#observers.add(observer);
+  }
 
-    this.#sessions.set(sessionId, {target, callbacks: new Map(), proxyConnection});
+  unobserve(observer: CDPConnectionObserver): void {
+    this.#observers.delete(observer);
+  }
+
+  registerSession(target: TargetBase, sessionId: string): void {
+    this.#sessions.set(sessionId, {target});
   }
 
   unregisterSession(sessionId: string): void {
@@ -245,13 +240,14 @@ export class SessionRouter {
     if (!session) {
       return;
     }
-    for (const {resolve, method} of session.callbacks.values()) {
+    for (const {resolve, method, sessionId: callbackSessionId} of this.#callbacks.values()) {
+      if (sessionId !== callbackSessionId) {
+        continue;
+      }
       resolve({
-        result: null,
         error: {
           message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-          code: ConnectionClosedErrorCode,
-          data: null,
+          code: CDPErrorStatus.SESSION_NOT_FOUND,
         }
       });
     }
@@ -266,10 +262,10 @@ export class SessionRouter {
     return this.#connection;
   }
 
-  sendMessage(sessionId: string, domain: string, method: QualifiedName, params: Object|null):
-      Promise<ResponseWithError> {
+  send<T extends Command>(method: T, params: CommandParams<T>, sessionId: string|undefined):
+      Promise<{result: CommandResult<T>}|{error: CDPError}> {
     const messageId = this.nextMessageId();
-    const messageObject: Message = {
+    const messageObject: Partial<CDPCommandRequest<T>> = {
       id: messageId,
       method,
     };
@@ -286,6 +282,7 @@ export class SessionRouter {
     }
 
     if (test.onMessageSent) {
+      const domain = method.split('.')[0];
       const paramsObject = JSON.parse(JSON.stringify(params || {}));
       test.onMessageSent({domain, method, params: (paramsObject as Object), id: messageId, sessionId});
     }
@@ -295,21 +292,21 @@ export class SessionRouter {
       this.#pendingLongPollingMessageIds.add(messageId);
     }
 
-    const session = this.#sessions.get(sessionId);
-    if (!session) {
-      return Promise.resolve({error: null, result: null});
-    }
-
     return new Promise(resolve => {
-      session.callbacks.set(messageId, {resolve, method});
+      this.#callbacks.set(messageId, {resolve, method, sessionId});
       this.#connection.sendRawMessage(JSON.stringify(messageObject));
     });
   }
 
   private sendRawMessageForTesting(method: QualifiedName, params: Object|null, callback: Callback|null, sessionId = ''):
       void {
-    const domain = method.split('.')[0];
-    void this.sendMessage(sessionId, domain, method, params).then(({error, result}) => callback?.(error, result));
+    void this.send(method as Command, params as CommandParams<Command>, sessionId).then(response => {
+      if ('error' in response && response.error) {
+        callback?.(response.error, null);
+      } else if ('result' in response) {
+        callback?.(null, response.result as Object | null);
+      }
+    });
   }
 
   private onMessage(message: string|Object): void {
@@ -322,71 +319,36 @@ export class SessionRouter {
       test.onMessageReceived(messageObjectCopy);
     }
 
-    const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message) as Message;
-
-    // Send all messages to proxy connections.
-    let suppressUnknownMessageErrors = false;
-    for (const session of this.#sessions.values()) {
-      if (!session.proxyConnection) {
-        continue;
-      }
-
-      if (!session.proxyConnection.onMessage) {
-        InspectorBackend.reportProtocolError(
-            'Protocol Error: the session has a proxyConnection with no _onMessage', messageObject);
-        continue;
-      }
-
-      session.proxyConnection.onMessage(messageObject);
-      suppressUnknownMessageErrors = true;
-    }
+    const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message) as CDPReceivableMessage;
 
     const sessionId = messageObject.sessionId || '';
     const session = this.#sessions.get(sessionId);
-    if (!session) {
-      // In the DevTools MCP case, we may share the transport with puppeteer so we silently
-      // ignore unknown sessions.
-      return;
-    }
-
-    // If this message is directly for the target controlled by the proxy connection, don't handle it.
-    if (session.proxyConnection) {
-      return;
-    }
 
-    if (session.target.getNeedsNodeJSPatching()) {
+    if (session?.target.getNeedsNodeJSPatching()) {
       NodeURL.patch(messageObject);
     }
 
-    if (messageObject.id !== undefined) {  // just a response for some request
-      const callback = session.callbacks.get(messageObject.id);
-      session.callbacks.delete(messageObject.id);
+    if ('id' in messageObject && messageObject.id !== undefined) {  // just a response for some request
+      const callback = this.#callbacks.get(messageObject.id);
+      this.#callbacks.delete(messageObject.id);
       if (!callback) {
-        if (messageObject.error?.code === ConnectionClosedErrorCode) {
-          // Ignore the errors that are sent as responses after the session closes.
-          return;
-        }
-        if (!suppressUnknownMessageErrors) {
-          InspectorBackend.reportProtocolError('Protocol Error: the message with wrong id', messageObject);
-        }
+        // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
         return;
       }
 
-      callback.resolve({error: messageObject.error || null, result: messageObject.result || null});
+      callback.resolve(messageObject);
       --this.#pendingResponsesCount;
       this.#pendingLongPollingMessageIds.delete(messageObject.id);
 
       if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
         this.deprecatedRunAfterPendingDispatches();
       }
-    } else {
-      if (messageObject.method === undefined) {
-        InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-        return;
-      }
+    } else if ('method' in messageObject) {
       // This cast is justified as we just checked for the presence of messageObject.method.
-      const eventMessage = messageObject as EventMessage;
-      session.target.dispatch(eventMessage);
+      session?.target.dispatch(messageObject as unknown as EventMessage);
+      this.#observers.forEach(observer => observer.onEvent(messageObject));
+    } else {
+      InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
     }
   }
 
@@ -842,6 +804,13 @@ export class TargetBase {
   }
 }
 
+/** These are not logged as console.error */
+const IGNORED_ERRORS = new Set<CDPErrorStatus>([
+  CDPErrorStatus.DEVTOOLS_STUB_ERROR,
+  CDPErrorStatus.SERVER_ERROR,
+  CDPErrorStatus.SESSION_NOT_FOUND,
+]);
+
 /**
  * This is a class that serves as the prototype for a domains #agents (every target
  * has it's own set of #agents). The InspectorBackend keeps an instance of this class
@@ -881,14 +850,18 @@ class AgentPrototype {
           {result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}`});
     }
 
-    return router.sendMessage(this.target.sessionId, this.domain, method, request).then(({error, result}) => {
-      if (error && !test.suppressRequestErrors && error.code !== DevToolsStubErrorCode &&
-          error.code !== GenericErrorCode && error.code !== ConnectionClosedErrorCode) {
-        console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
+    return router.send(method as Command, request as CommandParams<Command>, this.target.sessionId).then(response => {
+      if ('error' in response && response.error) {
+        if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
+          console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));
+        }
+        return {getError: () => response.error.message};
       }
 
-      const errorMessage = error?.message;
-      return {...result, getError: () => errorMessage};
+      if ('result' in response) {
+        return {...response.result, getError: () => undefined};
+      }
+      return {getError: () => undefined};
     });
   }
 }

package/front_end/core/protocol_client/NodeURL.ts

@@ -7,9 +7,7 @@ import * as Host from '../host/host.js';
 import type * as Platform from '../platform/platform.js';
 
 export class NodeURL {
-  static patch(object: {
-    url?: string,
-  }): void {
+  static patch(object: object): void {
     process(object, '');
 
     function process(object: {url?: string}, path: string): void {

package/front_end/core/sdk/ChildTargetManager.ts

@@ -7,9 +7,7 @@ import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
 import * as Host from '../host/host.js';
-import type * as ProtocolClient from '../protocol_client/protocol_client.js';
 
-import {ParallelConnection} from './Connections.js';
 import {PrimaryPageChangeType, ResourceTreeModel} from './ResourceTreeModel.js';
 import {SDKModel} from './SDKModel.js';
 import {SecurityOriginManager} from './SecurityOriginManager.js';
@@ -36,7 +34,6 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   readonly #targetInfos = new Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo>();
   readonly #childTargetsBySessionId = new Map<Protocol.Target.SessionID, Target>();
   readonly #childTargetsById = new Map<Protocol.Target.TargetID|'main', Target>();
-  readonly #parallelConnections = new Map<string, ProtocolClient.ConnectionTransport.ConnectionTransport>();
   #parentTargetId: Protocol.Target.TargetID|null = null;
 
   constructor(parentTarget: Target) {
@@ -244,15 +241,11 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   detachedFromTarget({sessionId}: Protocol.Target.DetachedFromTargetEvent): void {
-    if (this.#parallelConnections.has(sessionId)) {
-      this.#parallelConnections.delete(sessionId);
-    } else {
-      const target = this.#childTargetsBySessionId.get(sessionId);
-      if (target) {
-        target.dispose('target terminated');
-        this.#childTargetsBySessionId.delete(sessionId);
-        this.#childTargetsById.delete(target.id());
-      }
+    const target = this.#childTargetsBySessionId.get(sessionId);
+    if (target) {
+      target.dispose('target terminated');
+      this.#childTargetsBySessionId.delete(sessionId);
+      this.#childTargetsById.delete(target.id());
     }
   }
 
@@ -260,35 +253,6 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
     // We use flatten protocol.
   }
 
-  async createParallelConnection(onMessage: (arg0: Object|string) => void):
-      Promise<{connection: ProtocolClient.ConnectionTransport.ConnectionTransport, sessionId: string}> {
-    // 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);
-    connection.setOnMessage(onMessage);
-    this.#parallelConnections.set(sessionId, connection);
-    return {connection, sessionId};
-  }
-
-  private async createParallelConnectionAndSessionForTarget(target: Target, targetId: Protocol.Target.TargetID):
-      Promise<{
-        connection: ProtocolClient.ConnectionTransport.ConnectionTransport,
-        sessionId: string,
-      }> {
-    const targetAgent = target.targetAgent();
-    const targetRouter = (target.router() as ProtocolClient.InspectorBackend.SessionRouter);
-    const sessionId = (await targetAgent.invoke_attachToTarget({targetId, flatten: true})).sessionId;
-    const connection = new ParallelConnection(targetRouter.connection(), sessionId);
-    targetRouter.registerSession(target, sessionId, connection);
-    connection.setOnDisconnect(() => {
-      targetRouter.unregisterSession(sessionId);
-      void targetAgent.invoke_detachFromTarget({sessionId});
-    });
-    return {connection, sessionId};
-  }
-
   targetInfos(): Protocol.Target.TargetInfo[] {
     return Array.from(this.#targetInfos.values());
   }

package/front_end/core/sdk/Connections.ts

@@ -9,7 +9,7 @@ import type * as Platform from '../platform/platform.js';
 import * as ProtocolClient from '../protocol_client/protocol_client.js';
 import * as Root from '../root/root.js';
 
-import {RehydratingConnection} from './RehydratingConnection.js';
+import {RehydratingConnectionTransport} from './RehydratingConnection.js';
 
 const UIStrings = {
   /**
@@ -81,7 +81,7 @@ export class MainConnection implements ProtocolClient.ConnectionTransport.Connec
   }
 }
 
-export class WebSocketConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+export class WebSocketTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   #socket: WebSocket|null;
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
@@ -176,7 +176,7 @@ export class WebSocketConnection implements ProtocolClient.ConnectionTransport.C
   }
 }
 
-export class StubConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+export class StubTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
 
@@ -196,7 +196,7 @@ export class StubConnection implements ProtocolClient.ConnectionTransport.Connec
     const messageObject = JSON.parse(message);
     const error = {
       message: 'This is a stub connection, can\'t dispatch message.',
-      code: ProtocolClient.InspectorBackend.DevToolsStubErrorCode,
+      code: ProtocolClient.CDPConnection.CDPErrorStatus.DEVTOOLS_STUB_ERROR,
       data: messageObject,
     };
     if (this.onMessage) {
@@ -213,80 +213,31 @@ export class StubConnection implements ProtocolClient.ConnectionTransport.Connec
   }
 }
 
-export interface ParallelConnectionInterface extends ProtocolClient.ConnectionTransport.ConnectionTransport {
-  getSessionId: () => string;
-  getOnDisconnect: () => ((arg0: string) => void) | null;
-}
-
-export class ParallelConnection implements ParallelConnectionInterface {
-  readonly #connection: ProtocolClient.ConnectionTransport.ConnectionTransport;
-  #sessionId: string;
-  onMessage: ((arg0: Object) => void)|null = null;
-  #onDisconnect: ((arg0: string) => void)|null = null;
-  constructor(connection: ProtocolClient.ConnectionTransport.ConnectionTransport, sessionId: string) {
-    this.#connection = connection;
-    this.#sessionId = sessionId;
-  }
-
-  setOnMessage(onMessage: (arg0: Object) => void): void {
-    this.onMessage = onMessage;
-  }
-
-  setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.#onDisconnect = onDisconnect;
-  }
-
-  getOnDisconnect(): ((arg0: string) => void)|null {
-    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;
-    }
-    this.#connection.sendRawMessage(JSON.stringify(messageObject));
-  }
-
-  getSessionId(): string {
-    return this.#sessionId;
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.#onDisconnect) {
-      this.#onDisconnect.call(null, 'force disconnect');
-    }
-    this.#onDisconnect = null;
-    this.onMessage = null;
-  }
-}
-
 export async function initMainConnection(
     createRootTarget: () => Promise<void>,
     onConnectionLost: (message: Platform.UIString.LocalizedString) => void): Promise<void> {
-  ProtocolClient.ConnectionTransport.ConnectionTransport.setFactory(createMainConnection.bind(null, onConnectionLost));
+  ProtocolClient.ConnectionTransport.ConnectionTransport.setFactory(createMainTransport.bind(null, onConnectionLost));
   await createRootTarget();
   Host.InspectorFrontendHost.InspectorFrontendHostInstance.connectionReady();
 }
 
-function createMainConnection(onConnectionLost: (message: Platform.UIString.LocalizedString) => void):
+function createMainTransport(onConnectionLost: (message: Platform.UIString.LocalizedString) => void):
     ProtocolClient.ConnectionTransport.ConnectionTransport {
   if (Root.Runtime.Runtime.isTraceApp()) {
-    return new RehydratingConnection(onConnectionLost);
+    return new RehydratingConnectionTransport(onConnectionLost);
   }
 
   const wsParam = Root.Runtime.Runtime.queryParam('ws');
   const wssParam = Root.Runtime.Runtime.queryParam('wss');
   if (wsParam || wssParam) {
     const ws = (wsParam ? `ws://${wsParam}` : `wss://${wssParam}`) as Platform.DevToolsPath.UrlString;
-    return new WebSocketConnection(ws, onConnectionLost);
+    return new WebSocketTransport(ws, onConnectionLost);
   }
 
   const notEmbeddedOrWs = Host.InspectorFrontendHost.InspectorFrontendHostInstance.isHostedMode();
   if (notEmbeddedOrWs) {
     // eg., hosted mode (e.g. `http://localhost:9222/devtools/inspector.html`) without a WebSocket URL,
-    return new StubConnection();
+    return new StubTransport();
   }
 
   return new MainConnection();

package/front_end/core/sdk/DOMModel.ts

@@ -632,6 +632,7 @@ export class DOMNode {
   }
 
   async getSubtree(depth: number, pierce: boolean): Promise<DOMNode[]|null> {
+    console.assert(depth > 0, 'Do not fetch an infinite subtree to avoid crashing the renderer for large documents');
     const response = await this.#agent.invoke_requestChildNodes({nodeId: this.id, depth, pierce});
     return response.getError() ? null : this.childrenInternal;
   }

package/front_end/core/sdk/RehydratingConnection.ts

@@ -63,7 +63,7 @@ export const enum RehydratingConnectionState {
   REHYDRATED = 3,
 }
 
-export class RehydratingConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
+export class RehydratingConnectionTransport implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   rehydratingConnectionState: RehydratingConnectionState = RehydratingConnectionState.UNINITIALIZED;
   onDisconnect: ((arg0: string) => void)|null = null;
   onMessage: ((arg0: Object) => void)|null = null;