feat(electron): accept BrowserContextOptions in electron.launch (#6621)

Author: JoelEinbinder

docs/src/api/class-electron.md

@@ -76,3 +76,20 @@ Specifies environment variables that will be visible to Electron. Defaults to `p
 - `timeout` <[float]>
 
 Maximum time in milliseconds to wait for the application to start. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+
+### option: Electron.launch.acceptdownloads = %%-context-option-acceptdownloads-%%
+### option: Electron.launch.bypassCSP = %%-context-option-bypasscsp-%%
+### option: Electron.launch.colorScheme = %%-context-option-colorscheme-%%
+### option: Electron.launch.extraHTTPHeaders = %%-context-option-extrahttpheaders-%%
+### option: Electron.launch.geolocation = %%-context-option-geolocation-%%
+### option: Electron.launch.httpcredentials = %%-context-option-httpcredentials-%%
+### option: Electron.launch.ignoreHTTPSErrors = %%-context-option-ignorehttpserrors-%%
+### option: Electron.launch.locale = %%-context-option-locale-%%
+### option: Electron.launch.offline = %%-context-option-offline-%%
+### option: Electron.launch.recordhar = %%-context-option-recordhar-%%
+### option: Electron.launch.recordhar.path = %%-context-option-recordhar-path-%%
+### option: Electron.launch.recordhar.recordHarOmitContent = %%-context-option-recordhar-omit-content-%%
+### option: Electron.launch.recordvideo = %%-context-option-recordvideo-%%
+### option: Electron.launch.recordvideo.dir = %%-context-option-recordvideo-dir-%%
+### option: Electron.launch.recordvideo.size = %%-context-option-recordvideo-size-%%
+### option: Electron.launch.timezoneId = %%-context-option-timezoneid-%%

src/client/electron.ts

@@ -19,17 +19,19 @@ import * as structs from '../../types/structs';
 import * as api from '../../types/types';
 import * as channels from '../protocol/channels';
 import { TimeoutSettings } from '../utils/timeoutSettings';
+import { headersObjectToArray } from '../utils/utils';
 import { BrowserContext } from './browserContext';
 import { ChannelOwner } from './channelOwner';
 import { envObjectToArray } from './clientHelper';
 import { Events } from './events';
 import { JSHandle, parseResult, serializeArgument } from './jsHandle';
 import { Page } from './page';
-import { Env, WaitForEventOptions } from './types';
+import { Env, WaitForEventOptions, Headers } from './types';
 import { Waiter } from './waiter';
 
-type ElectronOptions = Omit<channels.ElectronLaunchOptions, 'env'> & {
+type ElectronOptions = Omit<channels.ElectronLaunchOptions, 'env'|'extraHTTPHeaders'> & {
   env?: Env,
+  extraHTTPHeaders?: Headers,
 };
 
 type ElectronAppType = typeof import('electron');
@@ -48,6 +50,7 @@ export class Electron extends ChannelOwner<channels.ElectronChannel, channels.El
       const params: channels.ElectronLaunchParams = {
         sdkLanguage: 'javascript',
         ...options,
+        extraHTTPHeaders: options.extraHTTPHeaders && headersObjectToArray(options.extraHTTPHeaders),
         env: envObjectToArray(options.env ? options.env : process.env),
       };
       return ElectronApplication.from((await channel.launch(params)).electronApplication);

src/protocol/channels.ts

@@ -2555,13 +2555,69 @@ export type ElectronLaunchParams = {
   cwd?: string,
   env?: NameValue[],
   timeout?: number,
+  acceptDownloads?: boolean,
+  bypassCSP?: boolean,
+  colorScheme?: 'dark' | 'light' | 'no-preference',
+  extraHTTPHeaders?: NameValue[],
+  geolocation?: {
+    longitude: number,
+    latitude: number,
+    accuracy?: number,
+  },
+  httpCredentials?: {
+    username: string,
+    password: string,
+  },
+  ignoreHTTPSErrors?: boolean,
+  locale?: string,
+  offline?: boolean,
+  recordHar?: {
+    omitContent?: boolean,
+    path: string,
+  },
+  recordVideo?: {
+    dir: string,
+    size?: {
+      width: number,
+      height: number,
+    },
+  },
+  timezoneId?: string,
 };
 export type ElectronLaunchOptions = {
   executablePath?: string,
   args?: string[],
   cwd?: string,
   env?: NameValue[],
   timeout?: number,
+  acceptDownloads?: boolean,
+  bypassCSP?: boolean,
+  colorScheme?: 'dark' | 'light' | 'no-preference',
+  extraHTTPHeaders?: NameValue[],
+  geolocation?: {
+    longitude: number,
+    latitude: number,
+    accuracy?: number,
+  },
+  httpCredentials?: {
+    username: string,
+    password: string,
+  },
+  ignoreHTTPSErrors?: boolean,
+  locale?: string,
+  offline?: boolean,
+  recordHar?: {
+    omitContent?: boolean,
+    path: string,
+  },
+  recordVideo?: {
+    dir: string,
+    size?: {
+      width: number,
+      height: number,
+    },
+  },
+  timezoneId?: string,
 };
 export type ElectronLaunchResult = {
   electronApplication: ElectronApplicationChannel,

src/protocol/protocol.yml

@@ -2094,6 +2094,47 @@ Electron:
           type: array?
           items: NameValue
         timeout: number?
+        acceptDownloads: boolean?
+        bypassCSP: boolean?
+        colorScheme:
+          type: enum?
+          literals:
+          - dark
+          - light
+          - no-preference
+        extraHTTPHeaders:
+          type: array?
+          items: NameValue
+        geolocation:
+          type: object?
+          properties:
+            longitude: number
+            latitude: number
+            accuracy: number?
+        httpCredentials:
+          type: object?
+          properties:
+            username: string
+            password: string
+        ignoreHTTPSErrors: boolean?
+        locale: string?
+        offline: boolean?
+        recordHar:
+          type: object?
+          properties:
+            omitContent: boolean?
+            path: string
+        recordVideo:
+          type: object?
+          properties:
+            dir: string
+            size:
+              type: object?
+              properties:
+                width: number
+                height: number
+        timezoneId: string?
+
       returns:
         electronApplication: ElectronApplication
 

src/protocol/validator.ts

@@ -973,6 +973,34 @@ export function createScheme(tChannel: (name: string) => Validator): Scheme {
     cwd: tOptional(tString),
     env: tOptional(tArray(tType('NameValue'))),
     timeout: tOptional(tNumber),
+    acceptDownloads: tOptional(tBoolean),
+    bypassCSP: tOptional(tBoolean),
+    colorScheme: tOptional(tEnum(['dark', 'light', 'no-preference'])),
+    extraHTTPHeaders: tOptional(tArray(tType('NameValue'))),
+    geolocation: tOptional(tObject({
+      longitude: tNumber,
+      latitude: tNumber,
+      accuracy: tOptional(tNumber),
+    })),
+    httpCredentials: tOptional(tObject({
+      username: tString,
+      password: tString,
+    })),
+    ignoreHTTPSErrors: tOptional(tBoolean),
+    locale: tOptional(tString),
+    offline: tOptional(tBoolean),
+    recordHar: tOptional(tObject({
+      omitContent: tOptional(tBoolean),
+      path: tString,
+    })),
+    recordVideo: tOptional(tObject({
+      dir: tString,
+      size: tOptional(tObject({
+        width: tNumber,
+        height: tNumber,
+      })),
+    })),
+    timezoneId: tOptional(tString),
   });
   scheme.ElectronApplicationBrowserWindowParams = tObject({
     page: tChannel('Page'),

src/server/electron/electron.ts

@@ -22,7 +22,6 @@ import * as js from '../javascript';
 import { Page } from '../page';
 import { TimeoutSettings } from '../../utils/timeoutSettings';
 import { WebSocketTransport } from '../transport';
-import * as types from '../types';
 import { launchProcess, envArrayToObject } from '../processLauncher';
 import { BrowserContext } from '../browserContext';
 import type {BrowserWindow} from 'electron';
@@ -33,15 +32,7 @@ import * as childProcess from 'child_process';
 import * as readline from 'readline';
 import { RecentLogsCollector } from '../../utils/debugLogger';
 import { internalCallMetadata, SdkObject } from '../instrumentation';
-
-export type ElectronLaunchOptionsBase = {
-  sdkLanguage: string,
-  executablePath?: string,
-  args?: string[],
-  cwd?: string,
-  env?: types.EnvArray,
-  timeout?: number,
-};
+import * as channels from '../../protocol/channels';
 
 export class ElectronApplication extends SdkObject {
   static Events = {
@@ -112,7 +103,7 @@ export class Electron extends SdkObject {
     this._playwrightOptions = playwrightOptions;
   }
 
-  async launch(options: ElectronLaunchOptionsBase): Promise<ElectronApplication> {
+  async launch(options: channels.ElectronLaunchParams): Promise<ElectronApplication> {
     const {
       args = [],
     } = options;
@@ -164,7 +155,22 @@ export class Electron extends SdkObject {
         name: 'electron',
         isChromium: true,
         headful: true,
-        persistent: { sdkLanguage: options.sdkLanguage, noDefaultViewport: true },
+        persistent: {
+          sdkLanguage: options.sdkLanguage,
+          noDefaultViewport: true,
+          acceptDownloads: options.acceptDownloads,
+          bypassCSP: options.bypassCSP,
+          colorScheme: options.colorScheme,
+          extraHTTPHeaders: options.extraHTTPHeaders,
+          geolocation: options.geolocation,
+          httpCredentials: options.httpCredentials,
+          ignoreHTTPSErrors: options.ignoreHTTPSErrors,
+          locale: options.locale,
+          offline: options.offline,
+          recordHar: options.recordHar,
+          recordVideo: options.recordVideo,
+          timezoneId: options.timezoneId,
+        },
         browserProcess,
         protocolLogger: helper.debugProtocolLogger(),
         browserLogsCollector,

tests/electron/electron-app.spec.ts

@@ -107,3 +107,22 @@ test('should return browser window', async ({ playwright }) => {
   expect(await bwHandle.evaluate((bw: BrowserWindow) => bw.title)).toBe('Electron');
   await electronApp.close();
 });
+
+test('should bypass csp', async ({playwright, server}) => {
+  const app = await playwright._electron.launch({
+    args: [require('path').join(__dirname, 'electron-app.js')],
+    bypassCSP: true,
+  });
+  await app.evaluate(electron => {
+    const window = new electron.BrowserWindow({
+      width: 800,
+      height: 600,
+    });
+    window.loadURL('about:blank');
+  });
+  const page = await app.firstWindow();
+  await page.goto(server.PREFIX + '/csp.html');
+  await page.addScriptTag({content: 'window["__injected"] = 42;'});
+  expect(await page.evaluate('window["__injected"]')).toBe(42);
+  await app.close();
+});