devtools-tracing 1.0.0

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

@@ -0,0 +1,314 @@
+// 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

@@ -0,0 +1,62 @@
+// 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

@@ -0,0 +1,293 @@
+// 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();
+}