devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/core/sdk/ChildTargetManager.ts

@@ -1,314 +0,0 @@
-// Copyright 2018 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as i18n from '../../core/i18n/i18n.js';
-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';
-import {StorageKeyManager} from './StorageKeyManager.js';
-import {Capability, type Target, Type} from './Target.js';
-import {Events as TargetManagerEvents, TargetManager} from './TargetManager.js';
-
-const UIStrings = {
-  /**
-   * @description Text that refers to the main target. The main target is the primary webpage that
-   * DevTools is connected to. This text is used in various places in the UI as a label/name to inform
-   * the user which target/webpage they are currently connected to, as DevTools may connect to multiple
-   * targets at the same time in some scenarios.
-   */
-  main: 'Main',
-} as const;
-const str_ = i18n.i18n.registerUIStrings('core/sdk/ChildTargetManager.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export class ChildTargetManager extends SDKModel<EventTypes> implements ProtocolProxyApi.TargetDispatcher {
-  readonly #targetManager: TargetManager;
-  #parentTarget: Target;
-  readonly #targetAgent: ProtocolProxyApi.TargetApi;
-  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) {
-    super(parentTarget);
-    this.#targetManager = parentTarget.targetManager();
-    this.#parentTarget = parentTarget;
-    this.#targetAgent = parentTarget.targetAgent();
-    parentTarget.registerTargetDispatcher(this);
-    const browserTarget = this.#targetManager.browserTarget();
-    if (browserTarget) {
-      if (browserTarget !== parentTarget) {
-        void browserTarget.targetAgent().invoke_autoAttachRelated(
-            {targetId: parentTarget.id() as Protocol.Target.TargetID, waitForDebuggerOnStart: true});
-      }
-    } else if (parentTarget.type() === Type.NODE) {
-      void this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: false});
-    } else {
-      void this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
-    }
-
-    if (parentTarget.parentTarget()?.type() !== Type.FRAME && !Host.InspectorFrontendHost.isUnderTest()) {
-      void this.#targetAgent.invoke_setDiscoverTargets({discover: true});
-      void this.#targetAgent.invoke_setRemoteLocations({locations: [{host: 'localhost', port: 9229}]});
-    }
-  }
-
-  static install(attachCallback?: ((arg0: {
-                                     target: Target,
-                                     waitingForDebugger: boolean,
-                                   }) => Promise<void>)): void {
-    ChildTargetManager.attachCallback = attachCallback;
-    SDKModel.register(ChildTargetManager, {capabilities: Capability.TARGET, autostart: true});
-  }
-
-  childTargets(): Target[] {
-    return Array.from(this.#childTargetsBySessionId.values());
-  }
-
-  override async suspendModel(): Promise<void> {
-    await this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: false, flatten: true});
-  }
-
-  override async resumeModel(): Promise<void> {
-    await this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
-  }
-
-  override dispose(): void {
-    for (const sessionId of this.#childTargetsBySessionId.keys()) {
-      this.detachedFromTarget({sessionId, targetId: undefined});
-    }
-  }
-
-  targetCreated({targetInfo}: Protocol.Target.TargetCreatedEvent): void {
-    this.#targetInfos.set(targetInfo.targetId, targetInfo);
-    this.fireAvailableTargetsChanged();
-    this.dispatchEventToListeners(Events.TARGET_CREATED, targetInfo);
-  }
-
-  targetInfoChanged({targetInfo}: Protocol.Target.TargetInfoChangedEvent): void {
-    this.#targetInfos.set(targetInfo.targetId, targetInfo);
-    const target = this.#childTargetsById.get(targetInfo.targetId);
-    if (target) {
-      void target.setHasCrashed(false);
-      if (target.targetInfo()?.subtype === 'prerender' && !targetInfo.subtype) {
-        const resourceTreeModel = target.model(ResourceTreeModel);
-        target.updateTargetInfo(targetInfo);
-        if (resourceTreeModel?.mainFrame) {
-          resourceTreeModel.primaryPageChanged(resourceTreeModel.mainFrame, PrimaryPageChangeType.ACTIVATION);
-        }
-        target.setName(i18nString(UIStrings.main));
-      } else {
-        target.updateTargetInfo(targetInfo);
-      }
-    }
-    this.fireAvailableTargetsChanged();
-    this.dispatchEventToListeners(Events.TARGET_INFO_CHANGED, targetInfo);
-  }
-
-  targetDestroyed({targetId}: Protocol.Target.TargetDestroyedEvent): void {
-    this.#targetInfos.delete(targetId);
-    this.fireAvailableTargetsChanged();
-    this.dispatchEventToListeners(Events.TARGET_DESTROYED, targetId);
-  }
-
-  targetCrashed({targetId}: Protocol.Target.TargetCrashedEvent): void {
-    const target = this.#childTargetsById.get(targetId);
-    if (target) {
-      target.setHasCrashed(true);
-    }
-  }
-
-  private fireAvailableTargetsChanged(): void {
-    TargetManager.instance().dispatchEventToListeners(
-        TargetManagerEvents.AVAILABLE_TARGETS_CHANGED, [...this.#targetInfos.values()]);
-  }
-
-  async getParentTargetId(): Promise<Protocol.Target.TargetID> {
-    if (!this.#parentTargetId) {
-      this.#parentTargetId = (await this.#parentTarget.targetAgent().invoke_getTargetInfo({})).targetInfo.targetId;
-    }
-    return this.#parentTargetId;
-  }
-
-  async getTargetInfo(): Promise<Protocol.Target.TargetInfo> {
-    return (await this.#parentTarget.targetAgent().invoke_getTargetInfo({})).targetInfo;
-  }
-
-  async attachedToTarget({sessionId, targetInfo, waitingForDebugger}: Protocol.Target.AttachedToTargetEvent):
-      Promise<void> {
-    if (this.#parentTargetId === targetInfo.targetId) {
-      return;
-    }
-    let type = Type.BROWSER;
-    let targetName = '';
-    if (targetInfo.type === 'worker' && targetInfo.title && targetInfo.title !== targetInfo.url) {
-      targetName = targetInfo.title;
-    } else if (!['page', 'iframe', 'webview'].includes(targetInfo.type)) {
-      const KNOWN_FRAME_PATTERNS = [
-        '^chrome://print/$',
-        '^chrome://file-manager/',
-        '^chrome://feedback/',
-        '^chrome://.*\\.top-chrome/$',
-        '^chrome://view-cert/$',
-        '^devtools://',
-      ];
-      if (KNOWN_FRAME_PATTERNS.some(p => targetInfo.url.match(p))) {
-        type = Type.FRAME;
-      } else {
-        const parsedURL = Common.ParsedURL.ParsedURL.fromString(targetInfo.url);
-        targetName =
-            parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + (++ChildTargetManager.lastAnonymousTargetId);
-      }
-    }
-
-    if (targetInfo.type === 'iframe' || targetInfo.type === 'webview') {
-      type = Type.FRAME;
-    } else if (targetInfo.type === 'background_page' || targetInfo.type === 'app' || targetInfo.type === 'popup_page') {
-      type = Type.FRAME;
-    } else if (targetInfo.type === 'page') {
-      type = Type.FRAME;
-    } else if (targetInfo.type === 'browser_ui') {
-      type = Type.FRAME;
-    } else if (targetInfo.type === 'worker') {
-      type = Type.Worker;
-    } else if (targetInfo.type === 'worklet') {
-      type = Type.WORKLET;
-    } else if (targetInfo.type === 'shared_worker') {
-      type = Type.SHARED_WORKER;
-    } else if (targetInfo.type === 'shared_storage_worklet') {
-      type = Type.SHARED_STORAGE_WORKLET;
-    } else if (targetInfo.type === 'service_worker') {
-      type = Type.ServiceWorker;
-    } else if (targetInfo.type === 'auction_worklet') {
-      type = Type.AUCTION_WORKLET;
-    } else if (targetInfo.type === 'node_worker') {
-      type = Type.NODE_WORKER;
-    }
-    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});
-    }
-
-    // [crbug/1423096] Invoking this on a worker session that is not waiting for the debugger can force the worker
-    // to resume even if there is another session waiting for the debugger.
-    if (waitingForDebugger) {
-      void target.runtimeAgent().invoke_runIfWaitingForDebugger();
-    }
-
-    // For top-level workers (those not attached to a frame), we need to
-    // initialize their storage context manually. The `Capability.STORAGE` is
-    // only granted in `Target.ts` to workers that are not parented by a frame,
-    // which makes this check safe. Frame-associated workers have their storage
-    // managed by ResourceTreeModel.
-    if (type !== Type.FRAME && target.hasAllCapabilities(Capability.STORAGE)) {
-      await this.initializeStorage(target);
-    }
-  }
-
-  private async initializeStorage(target: Target): Promise<void> {
-    const storageAgent = target.storageAgent();
-    const response = await storageAgent.invoke_getStorageKey({});
-
-    const storageKey = response.storageKey;
-    if (response.getError() || !storageKey) {
-      console.error(`Failed to get storage key for target ${target.id()}: ${response.getError()}`);
-      return;
-    }
-
-    const storageKeyManager = target.model(StorageKeyManager);
-    if (storageKeyManager) {
-      storageKeyManager.setMainStorageKey(storageKey);
-      storageKeyManager.updateStorageKeys(new Set([storageKey]));
-    }
-
-    const securityOriginManager = target.model(SecurityOriginManager);
-    if (securityOriginManager) {
-      const origin = new URL(storageKey).origin;
-      securityOriginManager.setMainSecurityOrigin(origin, '');
-      securityOriginManager.updateSecurityOrigins(new Set([origin]));
-    }
-  }
-
-  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());
-      }
-    }
-  }
-
-  receivedMessageFromTarget({}: Protocol.Target.ReceivedMessageFromTargetEvent): void {
-    // 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());
-  }
-
-  private static lastAnonymousTargetId = 0;
-
-  private static attachCallback?: ((arg0: {
-                                     target: Target,
-                                     waitingForDebugger: boolean,
-                                   }) => Promise<void>);
-}
-
-export const enum Events {
-  TARGET_CREATED = 'TargetCreated',
-  TARGET_DESTROYED = 'TargetDestroyed',
-  TARGET_INFO_CHANGED = 'TargetInfoChanged',
-}
-
-export interface EventTypes {
-  [Events.TARGET_CREATED]: Protocol.Target.TargetInfo;
-  [Events.TARGET_DESTROYED]: Protocol.Target.TargetID;
-  [Events.TARGET_INFO_CHANGED]: Protocol.Target.TargetInfo;
-}

package/lib/front_end/core/sdk/CompilerSourceMappingContentProvider.ts

@@ -1,62 +0,0 @@
-// Copyright 2011 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as TextUtils from '../../models/text_utils/text_utils.js';
-import type * as Common from '../common/common.js';
-import * as i18n from '../i18n/i18n.js';
-import type * as Platform from '../platform/platform.js';
-
-import {PageResourceLoader, type PageResourceLoadInitiator} from './PageResourceLoader.js';
-
-const UIStrings = {
-  /**
-   * @description Error message when failing to fetch a resource referenced in a source map
-   * @example {https://example.com/sourcemap.map} PH1
-   * @example {An error occurred} PH2
-   */
-  couldNotLoadContentForSS: 'Could not load content for {PH1} ({PH2})',
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('core/sdk/CompilerSourceMappingContentProvider.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export class CompilerSourceMappingContentProvider implements TextUtils.ContentProvider.ContentProvider {
-  readonly #sourceURL: Platform.DevToolsPath.UrlString;
-  readonly #contentType: Common.ResourceType.ResourceType;
-  readonly #initiator: PageResourceLoadInitiator;
-
-  constructor(
-      sourceURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType,
-      initiator: PageResourceLoadInitiator) {
-    this.#sourceURL = sourceURL;
-    this.#contentType = contentType;
-    this.#initiator = initiator;
-  }
-
-  contentURL(): Platform.DevToolsPath.UrlString {
-    return this.#sourceURL;
-  }
-
-  contentType(): Common.ResourceType.ResourceType {
-    return this.#contentType;
-  }
-
-  async requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError> {
-    try {
-      const {content} = await PageResourceLoader.instance().loadResource(this.#sourceURL, this.#initiator);
-      return new TextUtils.ContentData.ContentData(
-          content, /* isBase64=*/ false, this.#contentType.canonicalMimeType());
-    } catch (e) {
-      const error = i18nString(UIStrings.couldNotLoadContentForSS, {PH1: this.#sourceURL, PH2: e.message});
-      console.error(error);
-      return {error};
-    }
-  }
-
-  async searchInContent(query: string, caseSensitive: boolean, isRegex: boolean):
-      Promise<TextUtils.ContentProvider.SearchMatch[]> {
-    const contentData = await this.requestContentData();
-    return TextUtils.TextUtils.performSearchInContentData(contentData, query, caseSensitive, isRegex);
-  }
-}

package/lib/front_end/core/sdk/Connections.ts

@@ -1,293 +0,0 @@
-// Copyright 2015 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as i18n from '../../core/i18n/i18n.js';
-import * as Common from '../common/common.js';
-import * as Host from '../host/host.js';
-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';
-
-const UIStrings = {
-  /**
-   * @description Text on the remote debugging window to indicate the connection is lost
-   */
-  websocketDisconnected: 'WebSocket disconnected',
-} as const;
-const str_ = i18n.i18n.registerUIStrings('core/sdk/Connections.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-export class MainConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
-  onMessage: ((arg0: Object|string) => void)|null = null;
-  #onDisconnect: ((arg0: string) => void)|null = null;
-  #messageBuffer = '';
-  #messageSize = 0;
-  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
-  constructor() {
-    this.#eventListeners = [
-      Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
-          Host.InspectorFrontendHostAPI.Events.DispatchMessage, this.dispatchMessage, this),
-      Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
-          Host.InspectorFrontendHostAPI.Events.DispatchMessageChunk, this.dispatchMessageChunk, this),
-    ];
-  }
-
-  setOnMessage(onMessage: (arg0: Object|string) => void): void {
-    this.onMessage = onMessage;
-  }
-
-  setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.#onDisconnect = onDisconnect;
-  }
-
-  sendRawMessage(message: string): void {
-    if (this.onMessage) {
-      Host.InspectorFrontendHost.InspectorFrontendHostInstance.sendMessageToBackend(message);
-    }
-  }
-
-  private dispatchMessage(event: Common.EventTarget.EventTargetEvent<string>): void {
-    if (this.onMessage) {
-      this.onMessage.call(null, event.data);
-    }
-  }
-
-  private dispatchMessageChunk(
-      event: Common.EventTarget.EventTargetEvent<Host.InspectorFrontendHostAPI.DispatchMessageChunkEvent>): void {
-    const {messageChunk, messageSize} = event.data;
-    if (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;
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    const onDisconnect = this.#onDisconnect;
-    Common.EventTarget.removeEventListeners(this.#eventListeners);
-    this.#onDisconnect = null;
-    this.onMessage = null;
-
-    if (onDisconnect) {
-      onDisconnect.call(null, 'force disconnect');
-    }
-  }
-}
-
-export class WebSocketConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
-  #socket: WebSocket|null;
-  onMessage: ((arg0: Object|string) => void)|null = null;
-  #onDisconnect: ((arg0: string) => void)|null = null;
-  #onWebSocketDisconnect: ((message: Platform.UIString.LocalizedString) => void)|null;
-  #connected = false;
-  #messages: string[] = [];
-  constructor(
-      url: Platform.DevToolsPath.UrlString,
-      onWebSocketDisconnect: (message: Platform.UIString.LocalizedString) => 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.#onWebSocketDisconnect = onWebSocketDisconnect;
-  }
-
-  setOnMessage(onMessage: (arg0: Object|string) => void): void {
-    this.onMessage = onMessage;
-  }
-
-  setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.#onDisconnect = onDisconnect;
-  }
-
-  private onError(): void {
-    if (this.#onWebSocketDisconnect) {
-      this.#onWebSocketDisconnect.call(null, i18nString(UIStrings.websocketDisconnected));
-    }
-    if (this.#onDisconnect) {
-      // This is called if error occurred while connecting.
-      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.#messages = [];
-  }
-
-  private onClose(): void {
-    if (this.#onWebSocketDisconnect) {
-      this.#onWebSocketDisconnect.call(null, i18nString(UIStrings.websocketDisconnected));
-    }
-    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;
-    }
-    this.#onWebSocketDisconnect = null;
-  }
-
-  sendRawMessage(message: string): void {
-    if (this.#connected && this.#socket) {
-      this.#socket.send(message);
-    } else {
-      this.#messages.push(message);
-    }
-  }
-
-  disconnect(): Promise<void> {
-    return new Promise(fulfill => {
-      this.close(() => {
-        if (this.#onDisconnect) {
-          this.#onDisconnect.call(null, 'force disconnect');
-        }
-        fulfill();
-      });
-    });
-  }
-}
-
-export class StubConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
-  onMessage: ((arg0: Object|string) => void)|null = null;
-  #onDisconnect: ((arg0: string) => void)|null = null;
-
-  setOnMessage(onMessage: (arg0: Object|string) => void): void {
-    this.onMessage = onMessage;
-  }
-
-  setOnDisconnect(onDisconnect: (arg0: string) => void): void {
-    this.#onDisconnect = onDisconnect;
-  }
-
-  sendRawMessage(message: string): void {
-    window.setTimeout(this.respondWithError.bind(this, message), 0);
-  }
-
-  private respondWithError(message: string): void {
-    const messageObject = JSON.parse(message);
-    const error = {
-      message: 'This is a stub connection, can\'t dispatch message.',
-      code: ProtocolClient.InspectorBackend.DevToolsStubErrorCode,
-      data: messageObject,
-    };
-    if (this.onMessage) {
-      this.onMessage.call(null, {id: messageObject.id, error});
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.#onDisconnect) {
-      this.#onDisconnect.call(null, 'force disconnect');
-    }
-    this.#onDisconnect = null;
-    this.onMessage = null;
-  }
-}
-
-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));
-  await createRootTarget();
-  Host.InspectorFrontendHost.InspectorFrontendHostInstance.connectionReady();
-}
-
-function createMainConnection(onConnectionLost: (message: Platform.UIString.LocalizedString) => void):
-    ProtocolClient.ConnectionTransport.ConnectionTransport {
-  if (Root.Runtime.Runtime.isTraceApp()) {
-    return new RehydratingConnection(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);
-  }
-
-  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 MainConnection();
-}