[protocol] Nuke ParallelConnection/proxyConnection

LH and recorder player both use the new CDPConnection interface so
we can safely remove the parallel connection now.

Bug: 453469270
Change-Id: I5d42635f64e9c51af6a990f774a61bdc50119b7a
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7106262
Commit-Queue: Simon Zünd <[email protected]>
Reviewed-by: Alex Rudenko <[email protected]>

Author: szuend

front_end/core/protocol_client/InspectorBackend.ts

@@ -201,7 +201,6 @@ export class SessionRouter implements CDPConnection {
   readonly #pendingLongPollingMessageIds = new Set<number>();
   readonly #sessions = new Map<string, {
     target: TargetBase,
-    proxyConnection: ConnectionTransport|undefined|null,
   }>();
   #pendingScripts: Array<() => void> = [];
   readonly #callbacks = new Map<number, CallbackWithDebugInfo>();
@@ -232,19 +231,8 @@ export class SessionRouter implements CDPConnection {
     this.#observers.delete(observer);
   }
 
-  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;
-        }
-      }
-    }
-
-    this.#sessions.set(sessionId, {target, proxyConnection});
+  registerSession(target: TargetBase, sessionId: string): void {
+    this.#sessions.set(sessionId, {target});
   }
 
   unregisterSession(sessionId: string): void {
@@ -333,29 +321,9 @@ export class SessionRouter implements CDPConnection {
 
     const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message) as CDPReceivableMessage;
 
-    // Send all messages to proxy connections.
-    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);
-    }
-
     const sessionId = messageObject.sessionId || '';
     const session = this.#sessions.get(sessionId);
 
-    // 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()) {
       NodeURL.patch(messageObject);
     }

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,51 +241,18 @@ 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());
     }
   }
 
   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());
   }

front_end/core/sdk/Connections.ts

@@ -213,55 +213,6 @@ 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> {

front_end/services/puppeteer/PuppeteerConnection.ts

@@ -3,65 +3,10 @@
 // found in the LICENSE file.
 
 import type * as ProtocolClient from '../../core/protocol_client/protocol_client.js';
-import type * as SDK from '../../core/sdk/sdk.js';
 import type {ProtocolMapping} from '../../generated/protocol-mapping.js';
 import type * as Protocol from '../../generated/protocol.js';
 import * as puppeteer from '../../third_party/puppeteer/puppeteer.js';
 
-class Transport implements puppeteer.ConnectionTransport {
-  #connection: SDK.Connections.ParallelConnectionInterface;
-
-  constructor(connection: SDK.Connections.ParallelConnectionInterface) {
-    this.#connection = connection;
-  }
-
-  send(data: string): void {
-    this.#connection.sendRawMessage(data);
-  }
-
-  close(): void {
-    void this.#connection.disconnect();
-  }
-
-  set onmessage(cb: (message: string) => void) {
-    this.#connection.setOnMessage((message: unknown) => {
-      const data = (message) as {id: number, method: string, params: unknown, sessionId?: string};
-      if (!data.sessionId) {
-        return;
-      }
-
-      return cb(JSON.stringify({
-        ...data,
-        // Puppeteer is expecting to use the default session, but we give it a non-default session in #connection.
-        // Replace that sessionId with undefined so Puppeteer treats it as default.
-        sessionId: data.sessionId === this.#connection.getSessionId() ? undefined : data.sessionId,
-      }));
-    });
-  }
-
-  set onclose(cb: () => void) {
-    const prev = this.#connection.getOnDisconnect();
-    this.#connection.setOnDisconnect(reason => {
-      if (prev) {
-        prev(reason);
-      }
-      if (cb) {
-        cb();
-      }
-    });
-  }
-}
-
-class PuppeteerConnection extends puppeteer.Connection {
-  override async onMessage(message: string): Promise<void> {
-    const msgObj = JSON.parse(message) as {id: number, method: string, params: unknown, sessionId?: string};
-    if (msgObj.sessionId && !this._sessions.has(msgObj.sessionId)) {
-      return;
-    }
-    void super.onMessage(message);
-  }
-}
-
 /**
  * This class serves as a puppeteer.Connection while sending/receiving CDP messages
  * over DevTools' own SessionRouter.
@@ -124,49 +69,6 @@ class PuppeteerConnectionAdapter extends puppeteer.Connection implements
 }
 
 export class PuppeteerConnectionHelper {
-  /** @deprecated Use {@link connectPuppeteerToConnectionViaTab} instead. */
-  static async connectPuppeteerToConnectionViaTabLegacy(options: {
-    connection: SDK.Connections.ParallelConnectionInterface,
-    rootTargetId: string,
-    isPageTargetCallback: (targetInfo: Protocol.Target.TargetInfo) => boolean,
-  }): Promise<{
-    page: puppeteer.Page | null,
-    browser: puppeteer.Browser,
-    puppeteerConnection: puppeteer.Connection,
-  }> {
-    const {connection, rootTargetId, isPageTargetCallback} = options;
-    // Pass an empty message handler because it will be overwritten by puppeteer anyways.
-    const transport = new Transport(connection);
-
-    // url is an empty string in this case parallel to:
-    // https://github.com/puppeteer/puppeteer/blob/f63a123ecef86693e6457b07437a96f108f3e3c5/src/common/BrowserConnector.ts#L72
-    const puppeteerConnection = new PuppeteerConnection('', transport);
-
-    const browserPromise = puppeteer.Browser._create(
-        puppeteerConnection,
-        [] /* contextIds */,
-        false /* ignoreHTTPSErrors */,
-        undefined /* defaultViewport */,
-        undefined /* DownloadBehavior */,
-        undefined /* process */,
-        undefined /* closeCallback */,
-        undefined /* targetFilterCallback */,
-        target => isPageTargetCallback((target as puppeteer.Target)._getTargetInfo()),
-        false /* waitForInitiallyDiscoveredTargets */,
-    );
-
-    const [, browser] = await Promise.all([
-      puppeteerConnection._createSession({targetId: rootTargetId}, /* emulateAutoAttach= */ true),
-      browserPromise,
-    ]);
-
-    await browser.waitForTarget(t => t.type() === 'page');
-
-    const pages = await browser.pages();
-
-    return {page: pages[0] as puppeteer.Page, browser, puppeteerConnection};
-  }
-
   static async connectPuppeteerToConnectionViaTab(options: {
     connection: ProtocolClient.CDPConnection.CDPConnection,
     targetId: Protocol.Target.TargetID,