Simplify CDP client (#322)

Better type-safety, less memory used and more aligned with the CDP client in Puppeteer.
GoogleChromeLabs · Nov 24, 2022 · bebb0a8 · bebb0a8
1 parent 67a33f4
commit bebb0a8
Show file tree

Hide file tree

Showing 13 changed files with 4,958 additions and 268 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -5,7 +5,6 @@
   "main": "index.ts",
   "scripts": {
     "build": "npm run prettier && npm run clean && npm run build-mapper && npm run build-server",
-    "prebuild-mapper": "utils/filter_protocol_commands.js",
     "build-mapper": "rollup --config src/bidiMapper/rollup.config.js",
     "build-server": "tsc -b src/tsconfig.json",
     "clean": "rimraf src/.build",

diff --git a/src/bidiMapper/domains/context/browsingContextImpl.ts b/src/bidiMapper/domains/context/browsingContextImpl.ts
@@ -180,16 +180,18 @@ export class BrowsingContextImpl {
 
   async #unblockAttachedTarget() {
     LogManager.create(this.#cdpClient, this.#cdpSessionId, this.#eventManager);
-    await this.#cdpClient.Runtime.enable();
-    await this.#cdpClient.Page.enable();
-    await this.#cdpClient.Page.setLifecycleEventsEnabled({enabled: true});
-    await this.#cdpClient.Target.setAutoAttach({
+    await this.#cdpClient.sendCommand('Runtime.enable');
+    await this.#cdpClient.sendCommand('Page.enable');
+    await this.#cdpClient.sendCommand('Page.setLifecycleEventsEnabled', {
+      enabled: true,
+    });
+    await this.#cdpClient.sendCommand('Target.setAutoAttach', {
       autoAttach: true,
       waitForDebuggerOnStart: true,
       flatten: true,
     });
 
-    await this.#cdpClient.Runtime.runIfWaitingForDebugger();
+    await this.#cdpClient.sendCommand('Runtime.runIfWaitingForDebugger');
     this.#targetDefers.targetUnblocked.resolve();
   }
 
@@ -243,8 +245,8 @@ export class BrowsingContextImpl {
   }
 
   #initListeners() {
-    this.#cdpClient.Target.on(
-      'targetInfoChanged',
+    this.#cdpClient.on(
+      'Target.targetInfoChanged',
       (params: Protocol.Target.TargetInfoChangedEvent) => {
         if (this.contextId !== params.targetInfo.targetId) {
           return;
@@ -253,8 +255,8 @@ export class BrowsingContextImpl {
       }
     );
 
-    this.#cdpClient.Page.on(
-      'frameNavigated',
+    this.#cdpClient.on(
+      'Page.frameNavigated',
       async (params: Protocol.Page.FrameNavigatedEvent) => {
         if (this.contextId !== params.frame.id) {
           return;
@@ -271,8 +273,8 @@ export class BrowsingContextImpl {
       }
     );
 
-    this.#cdpClient.Page.on(
-      'navigatedWithinDocument',
+    this.#cdpClient.on(
+      'Page.navigatedWithinDocument',
       (params: Protocol.Page.NavigatedWithinDocumentEvent) => {
         if (this.contextId !== params.frameId) {
           return;
@@ -283,8 +285,8 @@ export class BrowsingContextImpl {
       }
     );
 
-    this.#cdpClient.Page.on(
-      'lifecycleEvent',
+    this.#cdpClient.on(
+      'Page.lifecycleEvent',
       async (params: Protocol.Page.LifecycleEventEvent) => {
         if (this.contextId !== params.frameId) {
           return;
@@ -334,8 +336,8 @@ export class BrowsingContextImpl {
       }
     );
 
-    this.#cdpClient.Runtime.on(
-      'executionContextCreated',
+    this.#cdpClient.on(
+      'Runtime.executionContextCreated',
       (params: Protocol.Runtime.ExecutionContextCreatedEvent) => {
         if (params.context.auxData.frameId !== this.contextId) {
           return;
@@ -365,8 +367,8 @@ export class BrowsingContextImpl {
       }
     );
 
-    this.#cdpClient.Runtime.on(
-      'executionContextDestroyed',
+    this.#cdpClient.on(
+      'Runtime.executionContextDestroyed',
       (params: Protocol.Runtime.ExecutionContextDestroyedEvent) => {
         Realm.findRealms({
           cdpSessionId: this.#cdpSessionId,
@@ -430,10 +432,13 @@ export class BrowsingContextImpl {
     await this.#targetDefers.targetUnblocked;
 
     // TODO: handle loading errors.
-    const cdpNavigateResult = await this.#cdpClient.Page.navigate({
-      url,
-      frameId: this.contextId,
-    });
+    const cdpNavigateResult = await this.#cdpClient.sendCommand(
+      'Page.navigate',
+      {
+        url,
+        frameId: this.contextId,
+      }
+    );
 
     if (cdpNavigateResult.errorText) {
       throw new UnknownException(cdpNavigateResult.errorText);
@@ -520,7 +525,7 @@ export class BrowsingContextImpl {
     });
 
     if (maybeSandboxes.length == 0) {
-      await this.#cdpClient.Page.createIsolatedWorld({
+      await this.#cdpClient.sendCommand('Page.createIsolatedWorld', {
         frameId: this.contextId,
         worldName: sandbox,
       });

diff --git a/src/bidiMapper/domains/context/browsingContextProcessor.ts b/src/bidiMapper/domains/context/browsingContextProcessor.ts
@@ -50,10 +50,10 @@ export class BrowsingContextProcessor {
   }
 
   #setTargetEventListeners(cdpClient: CdpClient) {
-    cdpClient.Target.on('attachedToTarget', async (params) => {
+    cdpClient.on('Target.attachedToTarget', async (params) => {
       await this.#handleAttachedToTargetEvent(params, cdpClient);
     });
-    cdpClient.Target.on('detachedFromTarget', async (params) => {
+    cdpClient.on('Target.detachedFromTarget', async (params) => {
       await BrowsingContextProcessor.#handleDetachedFromTargetEvent(params);
     });
   }
@@ -82,8 +82,8 @@ export class BrowsingContextProcessor {
       );
     });
 
-    sessionCdpClient.Page.on(
-      'frameAttached',
+    sessionCdpClient.on(
+      'Page.frameAttached',
       async (params: Protocol.Page.FrameAttachedEvent) => {
         await BrowsingContextImpl.createFrameContext(
           params.frameId,
@@ -106,8 +106,13 @@ export class BrowsingContextProcessor {
 
     if (!this.#isValidTarget(targetInfo)) {
       // DevTools or some other not supported by BiDi target.
-      await targetSessionCdpClient.Runtime.runIfWaitingForDebugger();
-      await parentSessionCdpClient.Target.detachFromTarget(params);
+      await targetSessionCdpClient.sendCommand(
+        'Runtime.runIfWaitingForDebugger'
+      );
+      await parentSessionCdpClient.sendCommand(
+        'Target.detachFromTarget',
+        params
+      );
       return;
     }
 
@@ -179,7 +184,7 @@ export class BrowsingContextProcessor {
       }
     }
 
-    const result = await browserCdpClient.Target.createTarget({
+    const result = await browserCdpClient.sendCommand('Target.createTarget', {
       url: 'about:blank',
       newWindow: params.type === 'window',
       ...(referenceContext?.cdpBrowserContextId
@@ -294,19 +299,21 @@ export class BrowsingContextProcessor {
         eventParams: Protocol.Target.DetachedFromTargetEvent
       ) => {
         if (eventParams.targetId === commandParams.context) {
-          browserCdpClient.Target.removeListener(
-            'detachedFromTarget',
+          browserCdpClient.removeListener(
+            'Target.detachedFromTarget',
             onContextDestroyed
           );
           resolve();
         }
       };
-      browserCdpClient.Target.on('detachedFromTarget', onContextDestroyed);
+      browserCdpClient.on('Target.detachedFromTarget', onContextDestroyed);
     });
 
-    await this.#cdpConnection.browserClient().Target.closeTarget({
-      targetId: commandParams.context,
-    });
+    await this.#cdpConnection
+      .browserClient()
+      .sendCommand('Target.closeTarget', {
+        targetId: commandParams.context,
+      });
 
     // Sometimes CDP command finishes before `detachedFromTarget` event,
     // sometimes after. Wait for the CDP command to be finished, and then wait

diff --git a/src/bidiMapper/domains/log/logManager.ts b/src/bidiMapper/domains/log/logManager.ts
@@ -57,8 +57,8 @@ export class LogManager {
   }
 
   #initializeLogEntryAddedEventListener() {
-    this.#cdpClient.Runtime.on(
-      'consoleAPICalled',
+    this.#cdpClient.on(
+      'Runtime.consoleAPICalled',
       (params: Protocol.Runtime.ConsoleAPICalledEvent) => {
         // Try to find realm by `cdpSessionId` and `executionContextId`,
         // if provided.
@@ -102,8 +102,8 @@ export class LogManager {
       }
     );
 
-    this.#cdpClient.Runtime.on(
-      'exceptionThrown',
+    this.#cdpClient.on(
+      'Runtime.exceptionThrown',
       (params: Protocol.Runtime.ExceptionThrownEvent) => {
         // Try to find realm by `cdpSessionId` and `executionContextId`,
         // if provided.