chore: make recorder a supplement (#5131)

src/cli/cli.ts

@@ -22,16 +22,17 @@ import * as path from 'path';
 import * as program from 'commander';
 import * as os from 'os';
 import * as fs from 'fs';
-import { OutputMultiplexer, TerminalOutput, FileOutput } from './codegen/outputs';
-import { CodeGenerator, CodeGeneratorOutput } from './codegen/codeGenerator';
-import { JavaScriptLanguageGenerator, LanguageGenerator } from './codegen/languages';
-import { PythonLanguageGenerator } from './codegen/languages/python';
-import { CSharpLanguageGenerator } from './codegen/languages/csharp';
-import { RecorderController } from './codegen/recorderController';
 import { runServer, printApiJson, installBrowsers } from './driver';
 import { showTraceViewer } from './traceViewer/traceViewer';
-import type { Browser, BrowserContext, Page, BrowserType, BrowserContextOptions, LaunchOptions } from '../..';
 import * as playwright from '../..';
+import { BrowserContext } from '../client/browserContext';
+import { Browser } from '../client/browser';
+import { Page } from '../client/page';
+import { BrowserType } from '../client/browserType';
+import { BrowserContextOptions, LaunchOptions } from '../client/types';
+import { RecorderOutput, RecorderSupplement } from '../client/supplements/recorderSupplement';
+import { ConsoleApiSupplement } from '../client/supplements/consoleApiSupplement';
+import { FileOutput, OutputMultiplexer, TerminalOutput } from '../client/supplements/recorderOutputs';
 
 program
     .version('Version ' + require('../../package.json').version)
@@ -317,36 +318,31 @@ async function openPage(context: BrowserContext, url: string | undefined): Promi
 
 async function open(options: Options, url: string | undefined) {
   const { context } = await launchContext(options, false);
-  (context as any)._exposeConsoleApi();
+  new ConsoleApiSupplement(context);
   await openPage(context, url);
   if (process.env.PWCLI_EXIT_FOR_TEST)
     await Promise.all(context.pages().map(p => p.close()));
 }
 
-async function codegen(options: Options, url: string | undefined, target: string, outputFile?: string) {
-  let languageGenerator: LanguageGenerator;
-
-  switch (target) {
-    case 'javascript': languageGenerator = new JavaScriptLanguageGenerator(); break;
-    case 'csharp': languageGenerator = new CSharpLanguageGenerator(); break;
-    case 'python':
-    case 'python-async': languageGenerator = new PythonLanguageGenerator(target === 'python-async'); break;
-    default: throw new Error(`Invalid target: '${target}'`);
-  }
-
-  const { context, browserName, launchOptions, contextOptions } = await launchContext(options, false);
-
-  if (process.env.PWTRACE)
-    (contextOptions as any)._traceDir = path.join(process.cwd(), '.trace');
-
-  const outputs: CodeGeneratorOutput[] = [TerminalOutput.create(process.stdout, languageGenerator.highlighterType())];
+async function codegen(options: Options, url: string | undefined, language: string, outputFile?: string) {
+  const { context, launchOptions, contextOptions } = await launchContext(options, false);
+  let highlighterType = language;
+  if (highlighterType === 'python-async')
+    highlighterType = 'python';
+  const outputs: RecorderOutput[] = [TerminalOutput.create(process.stdout, highlighterType)];
   if (outputFile)
     outputs.push(new FileOutput(outputFile));
   const output = new OutputMultiplexer(outputs);
 
-  const generator = new CodeGenerator(browserName, launchOptions, contextOptions, output, languageGenerator, options.device, options.saveStorage);
-  new RecorderController(context, generator);
-  (context as any)._exposeConsoleApi();
+  new ConsoleApiSupplement(context);
+  new RecorderSupplement(context,
+      language,
+      launchOptions,
+      contextOptions,
+      options.device,
+      options.saveStorage,
+      output);
+
   await openPage(context, url);
   if (process.env.PWCLI_EXIT_FOR_TEST)
     await Promise.all(context.pages().map(p => p.close()));
@@ -387,20 +383,23 @@ async function pdf(options: Options, captureOptions: CaptureOptions, url: string
   await browser.close();
 }
 
-function lookupBrowserType(options: Options): BrowserType<Browser> {
+function lookupBrowserType(options: Options): BrowserType {
   let name = options.browser;
   if (options.device) {
     const device = playwright.devices[options.device];
     name = device.defaultBrowserType;
   }
+  let browserType: any;
   switch (name) {
-    case 'chromium': return playwright.chromium!;
-    case 'webkit': return playwright.webkit!;
-    case 'firefox': return playwright.firefox!;
-    case 'cr': return playwright.chromium!;
-    case 'wk': return playwright.webkit!;
-    case 'ff': return playwright.firefox!;
+    case 'chromium': browserType = playwright.chromium; break;
+    case 'webkit': browserType = playwright.webkit; break;
+    case 'firefox': browserType = playwright.firefox; break;
+    case 'cr': browserType = playwright.chromium; break;
+    case 'wk': browserType = playwright.webkit; break;
+    case 'ff': browserType = playwright.firefox; break;
   }
+  if (browserType)
+    return browserType;
   program.help();
 }
 

src/cli/driver.ts

@@ -18,7 +18,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { installInspectorController } from '../server/inspector/inspectorController';
+import { installInspectorController } from '../server/supplements/inspectorController';
 import { DispatcherConnection } from '../dispatchers/dispatcher';
 import { PlaywrightDispatcher } from '../dispatchers/playwrightDispatcher';
 import { installBrowsersWithProgressBar } from '../install/installer';

src/client/browserContext.ts

@@ -253,14 +253,6 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel,
       throw e;
     }
   }
-
-  async _exposeConsoleApi() {
-    await this._channel.exposeConsoleApi();
-  }
-
-  async _enableRecorder<Arg>() {
-    await this._channel.enableRecorder();
-  }
 }
 
 export async function prepareBrowserContextOptions(options: BrowserContextOptions): Promise<channels.BrowserNewContextOptions> {

src/client/supplements/consoleApiSupplement.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { BrowserContext } from '../browserContext';
+
+export class ConsoleApiSupplement {
+  constructor(context: BrowserContext) {
+    context._channel.consoleSupplementExpose().catch(e => {});
+  }
+}

src/cli/codegen/outputs.ts → src/client/supplements/recorderOutputs.ts

@@ -18,11 +18,11 @@ import * as fs from 'fs';
 import * as querystring from 'querystring';
 import { Writable } from 'stream';
 import * as hljs from '../../third_party/highlightjs/highlightjs';
-import { CodeGeneratorOutput } from './codeGenerator';
+import { RecorderOutput } from './recorderSupplement';
 
-export class OutputMultiplexer implements CodeGeneratorOutput {
-  private _outputs: CodeGeneratorOutput[]
-  constructor(outputs: CodeGeneratorOutput[]) {
+export class OutputMultiplexer implements RecorderOutput {
+  private _outputs: RecorderOutput[]
+  constructor(outputs: RecorderOutput[]) {
     this._outputs = outputs;
   }
 
@@ -58,7 +58,7 @@ export class BufferOutput {
   }
 }
 
-export class FileOutput extends BufferOutput implements CodeGeneratorOutput {
+export class FileOutput extends BufferOutput implements RecorderOutput {
   private _fileName: string;
 
   constructor(fileName: string) {
@@ -71,7 +71,7 @@ export class FileOutput extends BufferOutput implements CodeGeneratorOutput {
   }
 }
 
-export class TerminalOutput implements CodeGeneratorOutput {
+export class TerminalOutput implements RecorderOutput {
   private _output: Writable
   private _language: string;
 
@@ -127,7 +127,7 @@ export class TerminalOutput implements CodeGeneratorOutput {
   flush() {}
 }
 
-export class FlushingTerminalOutput extends BufferOutput implements CodeGeneratorOutput {
+export class FlushingTerminalOutput extends BufferOutput implements RecorderOutput {
   private _output: Writable
 
   constructor(output: Writable) {

src/client/supplements/recorderSupplement.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as path from 'path';
+
+import { BrowserContext } from '../browserContext';
+import { BrowserContextOptions, LaunchOptions } from '../types';
+
+export class RecorderSupplement {
+  constructor(context: BrowserContext,
+    language: string,
+    launchOptions: LaunchOptions,
+    contextOptions: BrowserContextOptions,
+    device: string | undefined,
+    saveStorage: string | undefined,
+    output: RecorderOutput) {
+
+    if (process.env.PWTRACE)
+      contextOptions._traceDir = path.join(process.cwd(), '.trace');
+
+    context._channel.on('recorderSupplementPrintLn', event => output.printLn(event.text));
+    context._channel.on('recorderSupplementPopLn', event => output.popLn(event.text));
+    context.on('close', () => output.flush());
+    context._channel.recorderSupplementEnable({
+      language,
+      launchOptions,
+      contextOptions,
+      device,
+      saveStorage,
+    }).catch(e => {});
+  }
+}
+
+export interface RecorderOutput {
+  printLn(text: string): void;
+  popLn(text: string): void;
+  flush(): void;
+}

src/dispatchers/browserContextDispatcher.ts

@@ -21,6 +21,8 @@ import * as channels from '../protocol/channels';
 import { RouteDispatcher, RequestDispatcher } from './networkDispatchers';
 import { CRBrowserContext } from '../server/chromium/crBrowser';
 import { CDPSessionDispatcher } from './cdpSessionDispatcher';
+import { RecorderSupplement } from '../server/supplements/recorderSupplement';
+import { ConsoleApiSupplement } from '../server/supplements/consoleApiSupplement';
 
 export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channels.BrowserContextInitializer> implements channels.BrowserContextChannel {
   private _context: BrowserContext;
@@ -125,12 +127,17 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
     await this._context.close();
   }
 
-  async exposeConsoleApi(): Promise<void> {
-    await this._context.exposeConsoleApi();
+  async consoleSupplementExpose(): Promise<void> {
+    const consoleApi = new ConsoleApiSupplement(this._context);
+    await consoleApi.install();
   }
 
-  async enableRecorder(): Promise<void> {
-    await this._context.enableRecorder();
+  async recorderSupplementEnable(params: channels.BrowserContextRecorderSupplementEnableParams): Promise<void> {
+    const recorder = new RecorderSupplement(this._context, params, {
+      printLn: text => this._dispatchEvent('recorderSupplementPrintLn', { text }),
+      popLn: text => this._dispatchEvent('recorderSupplementPopLn', { text }),
+    });
+    await recorder.install();
   }
 
   async crNewCDPSession(params: channels.BrowserContextCrNewCDPSessionParams): Promise<channels.BrowserContextCrNewCDPSessionResult> {

src/inprocess.ts

@@ -20,7 +20,7 @@ import type { Playwright as PlaywrightAPI } from './client/playwright';
 import { PlaywrightDispatcher } from './dispatchers/playwrightDispatcher';
 import { Connection } from './client/connection';
 import { BrowserServerLauncherImpl } from './browserServerImpl';
-import { installInspectorController } from './server/inspector/inspectorController';
+import { installInspectorController } from './server/supplements/inspectorController';
 import { installTracer } from './trace/tracer';
 import { installHarTracer } from './trace/harTracer';
 import * as path from 'path';

src/protocol/channels.ts

@@ -535,6 +535,8 @@ export interface BrowserContextChannel extends Channel {
   on(event: 'route', callback: (params: BrowserContextRouteEvent) => void): this;
   on(event: 'crBackgroundPage', callback: (params: BrowserContextCrBackgroundPageEvent) => void): this;
   on(event: 'crServiceWorker', callback: (params: BrowserContextCrServiceWorkerEvent) => void): this;
+  on(event: 'recorderSupplementPrintLn', callback: (params: BrowserContextRecorderSupplementPrintLnEvent) => void): this;
+  on(event: 'recorderSupplementPopLn', callback: (params: BrowserContextRecorderSupplementPopLnEvent) => void): this;
   addCookies(params: BrowserContextAddCookiesParams, metadata?: Metadata): Promise<BrowserContextAddCookiesResult>;
   addInitScript(params: BrowserContextAddInitScriptParams, metadata?: Metadata): Promise<BrowserContextAddInitScriptResult>;
   clearCookies(params?: BrowserContextClearCookiesParams, metadata?: Metadata): Promise<BrowserContextClearCookiesResult>;
@@ -552,8 +554,8 @@ export interface BrowserContextChannel extends Channel {
   setNetworkInterceptionEnabled(params: BrowserContextSetNetworkInterceptionEnabledParams, metadata?: Metadata): Promise<BrowserContextSetNetworkInterceptionEnabledResult>;
   setOffline(params: BrowserContextSetOfflineParams, metadata?: Metadata): Promise<BrowserContextSetOfflineResult>;
   storageState(params?: BrowserContextStorageStateParams, metadata?: Metadata): Promise<BrowserContextStorageStateResult>;
-  exposeConsoleApi(params?: BrowserContextExposeConsoleApiParams, metadata?: Metadata): Promise<BrowserContextExposeConsoleApiResult>;
-  enableRecorder(params?: BrowserContextEnableRecorderParams, metadata?: Metadata): Promise<BrowserContextEnableRecorderResult>;
+  consoleSupplementExpose(params?: BrowserContextConsoleSupplementExposeParams, metadata?: Metadata): Promise<BrowserContextConsoleSupplementExposeResult>;
+  recorderSupplementEnable(params: BrowserContextRecorderSupplementEnableParams, metadata?: Metadata): Promise<BrowserContextRecorderSupplementEnableResult>;
   crNewCDPSession(params: BrowserContextCrNewCDPSessionParams, metadata?: Metadata): Promise<BrowserContextCrNewCDPSessionResult>;
 }
 export type BrowserContextBindingCallEvent = {
@@ -573,6 +575,12 @@ export type BrowserContextCrBackgroundPageEvent = {
 export type BrowserContextCrServiceWorkerEvent = {
   worker: WorkerChannel,
 };
+export type BrowserContextRecorderSupplementPrintLnEvent = {
+  text: string,
+};
+export type BrowserContextRecorderSupplementPopLnEvent = {
+  text: string,
+};
 export type BrowserContextAddCookiesParams = {
   cookies: SetNetworkCookie[],
 };
@@ -695,12 +703,21 @@ export type BrowserContextStorageStateResult = {
   cookies: NetworkCookie[],
   origins: OriginStorage[],
 };
-export type BrowserContextExposeConsoleApiParams = {};
-export type BrowserContextExposeConsoleApiOptions = {};
-export type BrowserContextExposeConsoleApiResult = void;
-export type BrowserContextEnableRecorderParams = {};
-export type BrowserContextEnableRecorderOptions = {};
-export type BrowserContextEnableRecorderResult = void;
+export type BrowserContextConsoleSupplementExposeParams = {};
+export type BrowserContextConsoleSupplementExposeOptions = {};
+export type BrowserContextConsoleSupplementExposeResult = void;
+export type BrowserContextRecorderSupplementEnableParams = {
+  language: string,
+  launchOptions: any,
+  contextOptions: any,
+  device?: string,
+  saveStorage?: string,
+};
+export type BrowserContextRecorderSupplementEnableOptions = {
+  device?: string,
+  saveStorage?: string,
+};
+export type BrowserContextRecorderSupplementEnableResult = void;
 export type BrowserContextCrNewCDPSessionParams = {
   page: PageChannel,
 };

src/protocol/protocol.yml

@@ -599,11 +599,17 @@ BrowserContext:
           type: array
           items: OriginStorage
 
-    exposeConsoleApi:
+    consoleSupplementExpose:
       experimental: True
 
-    enableRecorder:
+    recorderSupplementEnable:
       experimental: True
+      parameters:
+        language: string
+        launchOptions: json
+        contextOptions: json
+        device: string?
+        saveStorage: string?
 
     crNewCDPSession:
       parameters:
@@ -636,7 +642,13 @@ BrowserContext:
       parameters:
         worker: Worker
 
+    recorderSupplementPrintLn:
+      parameters:
+        text: string
 
+    recorderSupplementPopLn:
+      parameters:
+        text: string
 
 Page:
   type: interface