feat(rpc): switch Env to use an array, split ignoreDefaultArgs (#2984)

src/rpc/channels.ts

@@ -37,6 +37,24 @@ export type BrowserContextOptions = {
   colorScheme?: types.ColorScheme,
   acceptDownloads?: boolean,
 };
+type LaunchOptionsBase = {
+  executablePath?: string,
+  args?: string[],
+  ignoreAllDefaultArgs?: boolean,
+  ignoreDefaultArgs?: string[],
+  handleSIGINT?: boolean,
+  handleSIGTERM?: boolean,
+  handleSIGHUP?: boolean,
+  timeout?: number,
+  env?: types.EnvArray,
+  headless?: boolean,
+  devtools?: boolean,
+  proxy?: types.ProxySettings,
+  downloadsPath?: string,
+};
+export type LaunchOptions = LaunchOptionsBase & { slowMo?: number };
+export type LaunchServerOptions = LaunchOptionsBase & { port?: number };
+export type LaunchPersistentContextOptions = { userDataDir: string } & LaunchOptions & BrowserContextOptions;
 
 export interface Channel extends EventEmitter {
 }
@@ -60,11 +78,10 @@ export interface SelectorsChannel extends Channel {
 export type SelectorsInitializer = {};
 
 
-export type LaunchPersistentContextOptions = { userDataDir: string } & types.LaunchOptions & BrowserContextOptions;
 export interface BrowserTypeChannel extends Channel {
   connect(params: types.ConnectOptions): Promise<{ browser: BrowserChannel }>;
-  launch(params: types.LaunchOptions): Promise<{ browser: BrowserChannel }>;
+  launch(params: LaunchOptions): Promise<{ browser: BrowserChannel }>;
-  launchServer(params: types.LaunchServerOptions): Promise<{ server: BrowserServerChannel }>;
+  launchServer(params: LaunchServerOptions): Promise<{ server: BrowserServerChannel }>;
   launchPersistentContext(params: LaunchPersistentContextOptions): Promise<{ context: BrowserContextChannel }>;
 }
 export type BrowserTypeInitializer = {

src/rpc/client/browserType.ts

@@ -15,13 +15,13 @@
  */
 
 import * as types from '../../types';
-import { BrowserTypeChannel, BrowserTypeInitializer, LaunchPersistentContextOptions } from '../channels';
+import { BrowserTypeChannel, BrowserTypeInitializer, LaunchPersistentContextOptions, LaunchOptions, LaunchServerOptions } from '../channels';
 import { Browser } from './browser';
 import { BrowserContext } from './browserContext';
 import { ChannelOwner } from './channelOwner';
 import { BrowserServer } from './browserServer';
 import { LoggerSink } from '../../loggerSink';
-import { headersObjectToArray } from '../serializers';
+import { headersObjectToArray, envObjectToArray } from '../serializers';
 
 export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeInitializer> {
 
@@ -45,7 +45,13 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
     const logger = options.logger;
     options = { ...options, logger: undefined };
     return this._wrapApiCall('browserType.launch', async () => {
-      const browser = Browser.from((await this._channel.launch(options)).browser);
+      const launchOptions: LaunchOptions = {
+        ...options,
+        ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+        ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+        env: options.env ? envObjectToArray(options.env) : undefined,
+      };
+      const browser = Browser.from((await this._channel.launch(launchOptions)).browser);
       browser._logger = logger;
       return browser;
     }, logger);
@@ -55,7 +61,13 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
     const logger = options.logger;
     options = { ...options, logger: undefined };
     return this._wrapApiCall('browserType.launchServer', async () => {
-      return BrowserServer.from((await this._channel.launchServer(options)).server);
+      const launchServerOptions: LaunchServerOptions = {
+        ...options,
+        ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+        ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+        env: options.env ? envObjectToArray(options.env) : undefined,
+      };
+      return BrowserServer.from((await this._channel.launchServer(launchServerOptions)).server);
     }, logger);
   }
 
@@ -65,6 +77,9 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
     return this._wrapApiCall('browserType.launchPersistentContext', async () => {
       const persistentOptions: LaunchPersistentContextOptions = {
         ...options,
+        ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+        ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+        env: options.env ? envObjectToArray(options.env) : undefined,
         extraHTTPHeaders: options.extraHTTPHeaders ? headersObjectToArray(options.extraHTTPHeaders) : undefined,
         userDataDir,
       };

src/rpc/serializers.ts

@@ -126,3 +126,19 @@ export function headersArrayToObject(headers: types.HeadersArray): types.Headers
     result[name] = value;
   return result;
 }
+
+export function envObjectToArray(env: types.Env): types.EnvArray {
+  const result: types.EnvArray = [];
+  for (const name in env) {
+    if (!Object.is(env[name], undefined))
+      result.push({ name, value: String(env[name]) });
+  }
+  return result;
+}
+
+export function envArrayToObject(env: types.EnvArray): types.Env {
+  const result: types.Env = {};
+  for (const { name, value } of env)
+    result[name] = value;
+  return result;
+}

src/rpc/server/browserTypeDispatcher.ts

@@ -18,12 +18,12 @@ import { BrowserBase } from '../../browser';
 import { BrowserTypeBase, BrowserType } from '../../server/browserType';
 import * as types from '../../types';
 import { BrowserDispatcher } from './browserDispatcher';
-import { BrowserChannel, BrowserTypeChannel, BrowserContextChannel, BrowserTypeInitializer, BrowserServerChannel, LaunchPersistentContextOptions } from '../channels';
+import { BrowserChannel, BrowserTypeChannel, BrowserContextChannel, BrowserTypeInitializer, BrowserServerChannel, LaunchPersistentContextOptions, LaunchOptions, LaunchServerOptions } from '../channels';
 import { Dispatcher, DispatcherScope } from './dispatcher';
 import { BrowserContextBase } from '../../browserContext';
 import { BrowserContextDispatcher } from './browserContextDispatcher';
 import { BrowserServerDispatcher } from './browserServerDispatcher';
-import { headersArrayToObject } from '../serializers';
+import { headersArrayToObject, envArrayToObject } from '../serializers';
 
 export class BrowserTypeDispatcher extends Dispatcher<BrowserType, BrowserTypeInitializer> implements BrowserTypeChannel {
   constructor(scope: DispatcherScope, browserType: BrowserTypeBase) {
@@ -33,22 +33,34 @@ export class BrowserTypeDispatcher extends Dispatcher<BrowserType, BrowserTypeIn
     }, true, browserType.name());
   }
 
-  async launch(params: types.LaunchOptions): Promise<{ browser: BrowserChannel }> {
+  async launch(params: LaunchOptions): Promise<{ browser: BrowserChannel }> {
-    const browser = await this._object.launch(params);
+    const options = {
+      ...params,
+      ignoreDefaultArgs: params.ignoreAllDefaultArgs ? true : params.ignoreDefaultArgs,
+      env: params.env ? envArrayToObject(params.env) : undefined,
+    };
+    const browser = await this._object.launch(options);
     return { browser: new BrowserDispatcher(this._scope, browser as BrowserBase) };
   }
 
   async launchPersistentContext(params: LaunchPersistentContextOptions): Promise<{ context: BrowserContextChannel }> {
     const options = {
       ...params,
+      ignoreDefaultArgs: params.ignoreAllDefaultArgs ? true : params.ignoreDefaultArgs,
+      env: params.env ? envArrayToObject(params.env) : undefined,
       extraHTTPHeaders: params.extraHTTPHeaders ? headersArrayToObject(params.extraHTTPHeaders) : undefined,
     };
     const browserContext = await this._object.launchPersistentContext(params.userDataDir, options);
     return { context: new BrowserContextDispatcher(this._scope, browserContext as BrowserContextBase) };
   }
 
-  async launchServer(params: types.LaunchServerOptions): Promise<{ server: BrowserServerChannel }> {
+  async launchServer(params: LaunchServerOptions): Promise<{ server: BrowserServerChannel }> {
-    return { server: new BrowserServerDispatcher(this._scope, await this._object.launchServer(params)) };
+    const options = {
+      ...params,
+      ignoreDefaultArgs: params.ignoreAllDefaultArgs ? true : params.ignoreDefaultArgs,
+      env: params.env ? envArrayToObject(params.env) : undefined,
+    };
+    return { server: new BrowserServerDispatcher(this._scope, await this._object.launchServer(options)) };
   }
 
   async connect(params: types.ConnectOptions): Promise<{ browser: BrowserChannel }> {

src/types.ts

@@ -280,6 +280,7 @@ export type BrowserContextOptions = {
 };
 
 export type Env = {[key: string]: string | number | boolean | undefined};
+export type EnvArray = { name: string, value: string }[];
 
 export type LaunchOptionsBase = {
   executablePath?: string,