chore: print the launch error message to console (#2304)

src/logger.ts

@@ -41,24 +41,32 @@ export function logError(logger: InnerLogger): (error: Error) => void {
 }
 
 export class RootLogger implements InnerLogger {
-  private _userSink: Logger | undefined;
+  private _logger = new MultiplexingLogger();
-  private _debugSink: DebugLoggerSink;
 
   constructor(userSink: Logger | undefined) {
-    this._userSink = userSink;
+    if (userSink)
-    this._debugSink = new DebugLoggerSink();
+      this._logger.add('user', userSink);
+    this._logger.add('debug', new DebugLogger());
   }
 
   _isLogEnabled(log: Log): boolean {
-    return (this._userSink && this._userSink.isEnabled(log.name, log.severity || 'info')) ||
+    return this._logger.isEnabled(log.name, log.severity || 'info');
-        this._debugSink.isEnabled(log.name, log.severity || 'info');
   }
 
   _log(log: Log, message: string | Error, ...args: any[]) {
-    if (this._userSink && this._userSink.isEnabled(log.name, log.severity || 'info'))
+    if (this._logger.isEnabled(log.name, log.severity || 'info'))
-      this._userSink.log(log.name, log.severity || 'info', message, args, log.color ? { color: log.color } : {});
+      this._logger.log(log.name, log.severity || 'info', message, args, log.color ? { color: log.color } : {});
-    if (this._debugSink.isEnabled(log.name, log.severity || 'info'))
+  }
-      this._debugSink.log(log.name, log.severity || 'info', message, args, log.color ? { color: log.color } : {});
+
+  startLaunchRecording() {
+    this._logger.add(`launch`, new RecordingLogger('browser'));
+  }
+
+  stopLaunchRecording(): string {
+    const logger = this._logger.remove(`launch`) as RecordingLogger;
+    if (logger)
+      return logger.recording();
+    return '';
   }
 }
 
@@ -72,7 +80,55 @@ const colorMap = new Map<string, number>([
   ['reset', 0],
 ]);
 
-class DebugLoggerSink implements Logger {
+class MultiplexingLogger implements Logger {
+  private _loggers = new Map<string, Logger>();
+
+  add(id: string, logger: Logger) {
+    this._loggers.set(id, logger);
+  }
+
+  remove(id: string): Logger | undefined {
+    const logger = this._loggers.get(id);
+    this._loggers.delete(id);
+    return logger;
+  }
+
+  isEnabled(name: string, severity: LoggerSeverity): boolean {
+    for (const logger of this._loggers.values()) {
+      if (logger.isEnabled(name, severity))
+        return true;
+    }
+    return false;
+  }
+
+  log(name: string, severity: LoggerSeverity, message: string | Error, args: any[], hints: { color?: string }) {
+    for (const logger of this._loggers.values())
+      logger.log(name, severity, message, args, hints);
+  }
+}
+
+export class RecordingLogger implements Logger {
+  private _prefix: string;
+  private _recording: string[] = [];
+
+  constructor(prefix: string) {
+    this._prefix = prefix;
+  }
+
+  isEnabled(name: string, severity: LoggerSeverity): boolean {
+    return name.startsWith(this._prefix);
+  }
+
+  log(name: string, severity: LoggerSeverity, message: string | Error, args: any[], hints: { color?: string }) {
+    this._recording.push(String(message));
+  }
+
+  recording(): string {
+    return this._recording.join('\n');
+  }
+}
+
+class DebugLogger implements Logger {
   private _debuggers = new Map<string, debug.IDebugger>();
 
   isEnabled(name: string, severity: LoggerSeverity): boolean {

src/server/browserServer.ts

@@ -17,6 +17,9 @@
 import { ChildProcess, execSync } from 'child_process';
 import { EventEmitter } from 'events';
 import { helper } from '../helper';
+import { RootLogger } from '../logger';
+import { TimeoutSettings } from '../timeoutSettings';
+import { LaunchOptionsBase } from './browserType';
 
 export class WebSocketWrapper {
   readonly wsEndpoint: string;
@@ -48,19 +51,32 @@ export class WebSocketWrapper {
 }
 
 export class BrowserServer extends EventEmitter {
-  private _process: ChildProcess;
+  private _process: ChildProcess | undefined;
-  private _gracefullyClose: () => Promise<void>;
+  private _gracefullyClose: (() => Promise<void>) | undefined;
-  private _webSocketWrapper: WebSocketWrapper | null;
+  private _webSocketWrapper: WebSocketWrapper | null = null;
+  private _launchOptions: LaunchOptionsBase;
+  readonly _logger: RootLogger;
+  readonly _launchDeadline: number;
 
-  constructor(process: ChildProcess, gracefullyClose: () => Promise<void>, webSocketWrapper: WebSocketWrapper | null) {
+  constructor(options: LaunchOptionsBase) {
     super();
+    this._launchOptions = options;
+    this._logger = new RootLogger(options.logger);
+    this._launchDeadline = TimeoutSettings.computeDeadline(typeof options.timeout === 'number' ? options.timeout : 30000);
+  }
+
+  _initialize(process: ChildProcess, gracefullyClose: () => Promise<void>, webSocketWrapper: WebSocketWrapper | null) {
     this._process = process;
     this._gracefullyClose = gracefullyClose;
     this._webSocketWrapper = webSocketWrapper;
   }
 
+  _isInitialized(): boolean {
+    return !!this._process;
+  }
+
   process(): ChildProcess {
-    return this._process;
+    return this._process!;
   }
 
   wsEndpoint(): string {
@@ -68,12 +84,12 @@ export class BrowserServer extends EventEmitter {
   }
 
   kill() {
-    if (this._process.pid && !this._process.killed) {
+    if (this._process!.pid && !this._process!.killed) {
       try {
         if (process.platform === 'win32')
-          execSync(`taskkill /pid ${this._process.pid} /T /F`);
+          execSync(`taskkill /pid ${this._process!.pid} /T /F`);
         else
-          process.kill(-this._process.pid, 'SIGKILL');
+          process.kill(-this._process!.pid, 'SIGKILL');
       } catch (e) {
         // the process might have already stopped
       }
@@ -81,7 +97,7 @@ export class BrowserServer extends EventEmitter {
   }
 
   async close(): Promise<void> {
-    await this._gracefullyClose();
+    await this._gracefullyClose!();
   }
 
   async _checkLeaks(): Promise<void> {
@@ -89,19 +105,28 @@ export class BrowserServer extends EventEmitter {
       await this._webSocketWrapper.checkLeaks();
   }
 
-  async _initializeOrClose<T>(deadline: number, init: () => Promise<T>): Promise<T> {
+  async _initializeOrClose<T>(init: () => Promise<T>): Promise<T> {
     try {
-      const result = await helper.waitWithDeadline(init(), 'the browser to launch', deadline, 'pw:browser*');
+      let promise: Promise<T>;
+      if ((this._launchOptions as any).__testHookBeforeCreateBrowser)
+        promise = (this._launchOptions as any).__testHookBeforeCreateBrowser().then(init);
+      else
+        promise = init();
+      const result = await helper.waitWithDeadline(promise, 'the browser to launch', this._launchDeadline, 'pw:browser*');
+      this._logger.stopLaunchRecording();
       return result;
     } catch (e) {
-      await this._closeOrKill(deadline);
+      e.message += '\n=============== Process output during launch: ===============\n' +
+          this._logger.stopLaunchRecording() +
+          '\n=============================================================';
+      await this._closeOrKill();
       throw e;
     }
   }
 
-  async _closeOrKill(deadline: number): Promise<void> {
+  private async _closeOrKill(): Promise<void> {
     try {
-      await helper.waitWithDeadline(this.close(), '', deadline, ''); // The error message is ignored.
+      await helper.waitWithDeadline(this.close(), '', this._launchDeadline, ''); // The error message is ignored.
     } catch (ignored) {
       this.kill();
     }

src/server/browserType.ts

@@ -25,7 +25,7 @@ export type BrowserArgOptions = {
   devtools?: boolean,
 };
 
-type LaunchOptionsBase = BrowserArgOptions & {
+export type LaunchOptionsBase = BrowserArgOptions & {
   executablePath?: string,
   ignoreDefaultArgs?: boolean | string[],
   handleSIGINT?: boolean,

src/server/chromium.ts

@@ -19,7 +19,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import * as util from 'util';
-import { helper, assert, isDebugMode } from '../helper';
+import { helper, assert, isDebugMode, debugAssert } from '../helper';
 import { CRBrowser } from '../chromium/crBrowser';
 import * as ws from 'ws';
 import { launchProcess } from './processLauncher';
@@ -33,7 +33,6 @@ import { ConnectionTransport, ProtocolRequest, WebSocketTransport } from '../tra
 import { BrowserContext } from '../browserContext';
 import { InnerLogger, logError, RootLogger } from '../logger';
 import { BrowserDescriptor } from '../install/browserPaths';
-import { TimeoutSettings } from '../timeoutSettings';
 import { CRDevTools } from '../chromium/crDevTools';
 
 export class Chromium extends AbstractBrowserType<CRBrowser> {
@@ -51,12 +50,9 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
 
   async launch(options: LaunchOptions = {}): Promise<CRBrowser> {
     assert(!(options as any).userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
-    const { timeout = 30000 } = options;
+    const browserServer = new BrowserServer(options);
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const { transport, downloadsPath } = await this._launchServer(options, 'local', browserServer);
-    const { browserServer, transport, downloadsPath, logger } = await this._launchServer(options, 'local');
+    return await browserServer._initializeOrClose(async () => {
-    return await browserServer._initializeOrClose(deadline, async () => {
-      if ((options as any).__testHookBeforeCreateBrowser)
-        await (options as any).__testHookBeforeCreateBrowser();
       let devtools = this._devtools;
       if ((options as any).__testHookForDevTools) {
         devtools = this._createDevTools();
@@ -65,7 +61,7 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
       return await CRBrowser.connect(transport!, {
         slowMo: options.slowMo,
         headful: !processBrowserArgOptions(options).headless,
-        logger,
+        logger: browserServer._logger,
         downloadsPath,
         ownedServer: browserServer,
       }, devtools);
@@ -73,20 +69,19 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
   }
 
   async launchServer(options: LaunchServerOptions = {}): Promise<BrowserServer> {
-    return (await this._launchServer(options, 'server')).browserServer;
+    const browserServer = new BrowserServer(options);
+    await this._launchServer(options, 'server', browserServer);
+    return browserServer;
   }
 
   async launchPersistentContext(userDataDir: string, options: LaunchOptions = {}): Promise<BrowserContext> {
-    const { timeout = 30000 } = options;
+    const browserServer = new BrowserServer(options);
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const { transport, downloadsPath } = await this._launchServer(options, 'persistent', browserServer, userDataDir);
-    const { transport, browserServer, downloadsPath, logger } = await this._launchServer(options, 'persistent', userDataDir);
+    return await browserServer._initializeOrClose(async () => {
-    return await browserServer._initializeOrClose(deadline, async () => {
-      if ((options as any).__testHookBeforeCreateBrowser)
-        await (options as any).__testHookBeforeCreateBrowser();
       const browser = await CRBrowser.connect(transport!, {
         slowMo: options.slowMo,
         persistent: true,
-        logger,
+        logger: browserServer._logger,
         downloadsPath,
         headful: !processBrowserArgOptions(options).headless,
         ownedServer: browserServer
@@ -98,7 +93,7 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
     });
   }
 
-  private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, userDataDir?: string): Promise<{ browserServer: BrowserServer, transport?: ConnectionTransport, downloadsPath: string, logger: InnerLogger }> {
+  private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, browserServer: BrowserServer, userDataDir?: string): Promise<{ transport?: ConnectionTransport, downloadsPath: string }> {
     const {
       ignoreDefaultArgs = false,
       args = [],
@@ -110,7 +105,7 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
       port = 0,
     } = options;
     assert(!port || launchType === 'server', 'Cannot specify a port without launching as a server.');
-    const logger = new RootLogger(options.logger);
+    const logger = browserServer._logger;
 
     let temporaryUserDataDir: string | null = null;
     if (!userDataDir) {
@@ -136,7 +131,6 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
     // Note: it is important to define these variables before launchProcess, so that we don't get
     // "Cannot access 'browserServer' before initialization" if something went wrong.
     let transport: PipeTransport | undefined = undefined;
-    let browserServer: BrowserServer | undefined = undefined;
     const { launchedProcess, gracefullyClose, downloadsPath } = await launchProcess({
       executablePath: chromeExecutable,
       args: chromeArguments,
@@ -148,7 +142,7 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
       pipe: true,
       tempDir: temporaryUserDataDir || undefined,
       attemptToGracefullyClose: async () => {
-        assert(browserServer);
+        debugAssert(browserServer._isInitialized());
         // We try to gracefully close to prevent crash reporting and core dumps.
         // Note that it's fine to reuse the pipe transport, since
         // our connection ignores kBrowserCloseMessageId.
@@ -157,15 +151,14 @@ export class Chromium extends AbstractBrowserType<CRBrowser> {
         t.send(message);
       },
       onkill: (exitCode, signal) => {
-        if (browserServer)
+        browserServer.emit(Events.BrowserServer.Close, exitCode, signal);
-          browserServer.emit(Events.BrowserServer.Close, exitCode, signal);
       },
     });
 
     const stdio = launchedProcess.stdio as unknown as [NodeJS.ReadableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.ReadableStream];
     transport = new PipeTransport(stdio[3], stdio[4], logger);
-    browserServer = new BrowserServer(launchedProcess, gracefullyClose, launchType === 'server' ? wrapTransportWithWebSocket(transport, logger, port) : null);
+    browserServer._initialize(launchedProcess, gracefullyClose, launchType === 'server' ? wrapTransportWithWebSocket(transport, logger, port) : null);
-    return { browserServer, transport, downloadsPath, logger };
+    return { transport, downloadsPath };
   }
 
   async connect(options: ConnectOptions): Promise<CRBrowser> {

src/server/electron.ts

@@ -167,9 +167,8 @@ export class Electron  {
       handleSIGINT = true,
       handleSIGTERM = true,
       handleSIGHUP = true,
-      timeout = 30000,
     } = options;
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const browserServer = new BrowserServer(options);
 
     let app: ElectronApplication | undefined = undefined;
 
@@ -193,6 +192,7 @@ export class Electron  {
       },
     });
 
+    const deadline = browserServer._launchDeadline;
     const timeoutError = new TimeoutError(`Timed out while trying to connect to Electron!`);
     const nodeMatch = await waitForLine(launchedProcess, launchedProcess.stderr, /^Debugger listening on (ws:\/\/.*)$/, helper.timeUntilDeadline(deadline), timeoutError);
     const nodeConnection = await WebSocketTransport.connect(nodeMatch[1], transport => {
@@ -203,7 +203,7 @@ export class Electron  {
     const chromeTransport = await WebSocketTransport.connect(chromeMatch[1], transport => {
       return transport;
     }, logger);
-    const browserServer = new BrowserServer(launchedProcess, gracefullyClose, null);
+    browserServer._initialize(launchedProcess, gracefullyClose, null);
     const browser = await CRBrowser.connect(chromeTransport, { headful: true, logger, persistent: true, viewport: null, ownedServer: browserServer, downloadsPath: '' });
     app = new ElectronApplication(logger, browser, nodeConnection);
     await app._init();

src/server/firefox.ts

@@ -26,14 +26,13 @@ import { TimeoutError } from '../errors';
 import { Events } from '../events';
 import { FFBrowser } from '../firefox/ffBrowser';
 import { kBrowserCloseMessageId } from '../firefox/ffConnection';
-import { helper, assert } from '../helper';
+import { helper, assert, debugAssert } from '../helper';
 import { BrowserServer, WebSocketWrapper } from './browserServer';
 import { BrowserArgOptions, LaunchOptions, LaunchServerOptions, ConnectOptions, AbstractBrowserType, processBrowserArgOptions } from './browserType';
 import { launchProcess, waitForLine } from './processLauncher';
 import { ConnectionTransport, SequenceNumberMixer, WebSocketTransport } from '../transport';
 import { RootLogger, InnerLogger, logError } from '../logger';
 import { BrowserDescriptor } from '../install/browserPaths';
-import { TimeoutSettings } from '../timeoutSettings';
 
 const mkdtempAsync = util.promisify(fs.mkdtemp);
 
@@ -44,46 +43,42 @@ export class Firefox extends AbstractBrowserType<FFBrowser> {
 
   async launch(options: LaunchOptions = {}): Promise<FFBrowser> {
     assert(!(options as any).userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
-    const { timeout = 30000 } = options;
+    const browserServer = new BrowserServer(options);
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const { downloadsPath } = await this._launchServer(options, 'local', browserServer);
-    const { browserServer, downloadsPath, logger } = await this._launchServer(options, 'local');
+    return await browserServer._initializeOrClose(async () => {
-    return await browserServer._initializeOrClose(deadline, async () => {
-      if ((options as any).__testHookBeforeCreateBrowser)
-        await (options as any).__testHookBeforeCreateBrowser();
       const browser = await WebSocketTransport.connect(browserServer.wsEndpoint()!, transport => {
         return FFBrowser.connect(transport, {
           slowMo: options.slowMo,
-          logger,
+          logger: browserServer._logger,
           downloadsPath,
           headful: !processBrowserArgOptions(options).headless,
           ownedServer: browserServer,
         });
-      }, logger);
+      }, browserServer._logger);
       return browser;
     });
   }
 
   async launchServer(options: LaunchServerOptions = {}): Promise<BrowserServer> {
-    return (await this._launchServer(options, 'server')).browserServer;
+    const browserServer = new BrowserServer(options);
+    await this._launchServer(options, 'server', browserServer);
+    return browserServer;
   }
 
   async launchPersistentContext(userDataDir: string, options: LaunchOptions = {}): Promise<BrowserContext> {
-    const { timeout = 30000 } = options;
+    const browserServer = new BrowserServer(options);
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const { downloadsPath } = await this._launchServer(options, 'persistent', browserServer, userDataDir);
-    const { browserServer, downloadsPath, logger } = await this._launchServer(options, 'persistent', userDataDir);
+    return await browserServer._initializeOrClose(async () => {
-    return await browserServer._initializeOrClose(deadline, async () => {
-      if ((options as any).__testHookBeforeCreateBrowser)
-        await (options as any).__testHookBeforeCreateBrowser();
       const browser = await WebSocketTransport.connect(browserServer.wsEndpoint()!, transport => {
         return FFBrowser.connect(transport, {
           slowMo: options.slowMo,
-          logger,
+          logger: browserServer._logger,
           persistent: true,
           downloadsPath,
           ownedServer: browserServer,
           headful: !processBrowserArgOptions(options).headless,
         });
-      }, logger);
+      }, browserServer._logger);
       const context = browser._defaultContext!;
       if (!options.ignoreDefaultArgs || Array.isArray(options.ignoreDefaultArgs))
         await context._loadDefaultContext();
@@ -91,7 +86,7 @@ export class Firefox extends AbstractBrowserType<FFBrowser> {
     });
   }
 
-  private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, userDataDir?: string): Promise<{ browserServer: BrowserServer, downloadsPath: string, logger: InnerLogger }> {
+  private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, browserServer: BrowserServer, userDataDir?: string): Promise<{ downloadsPath: string }> {
     const {
       ignoreDefaultArgs = false,
       args = [],
@@ -104,7 +99,7 @@ export class Firefox extends AbstractBrowserType<FFBrowser> {
       port = 0,
     } = options;
     assert(!port || launchType === 'server', 'Cannot specify a port without launching as a server.');
-    const logger = new RootLogger(options.logger);
+    const logger = browserServer._logger;
 
     let temporaryProfileDir = null;
     if (!userDataDir) {
@@ -126,7 +121,6 @@ export class Firefox extends AbstractBrowserType<FFBrowser> {
 
     // Note: it is important to define these variables before launchProcess, so that we don't get
     // "Cannot access 'browserServer' before initialization" if something went wrong.
-    let browserServer: BrowserServer | undefined = undefined;
     let browserWSEndpoint: string | undefined = undefined;
     const { launchedProcess, gracefullyClose, downloadsPath } = await launchProcess({
       executablePath: firefoxExecutable,
@@ -143,15 +137,14 @@ export class Firefox extends AbstractBrowserType<FFBrowser> {
       pipe: false,
       tempDir: temporaryProfileDir || undefined,
       attemptToGracefullyClose: async () => {
-        assert(browserServer);
+        debugAssert(browserServer._isInitialized());
         // We try to gracefully close to prevent crash reporting and core dumps.
         const transport = await WebSocketTransport.connect(browserWSEndpoint!, async transport => transport);
         const message = { method: 'Browser.close', params: {}, id: kBrowserCloseMessageId };
         await transport.send(message);
       },
       onkill: (exitCode, signal) => {
-        if (browserServer)
+        browserServer.emit(Events.BrowserServer.Close, exitCode, signal);
-          browserServer.emit(Events.BrowserServer.Close, exitCode, signal);
       },
     });
 
@@ -163,8 +156,8 @@ export class Firefox extends AbstractBrowserType<FFBrowser> {
       (await WebSocketTransport.connect(innerEndpoint, t => wrapTransportWithWebSocket(t, logger, port), logger)) :
       new WebSocketWrapper(innerEndpoint, []);
     browserWSEndpoint = webSocketWrapper.wsEndpoint;
-    browserServer = new BrowserServer(launchedProcess, gracefullyClose, webSocketWrapper);
+    browserServer._initialize(launchedProcess, gracefullyClose, webSocketWrapper);
-    return { browserServer, downloadsPath, logger };
+    return { downloadsPath };
   }
 
   async connect(options: ConnectOptions): Promise<FFBrowser> {

src/server/processLauncher.ts

@@ -16,7 +16,7 @@
  */
 
 import * as childProcess from 'child_process';
-import { Log, InnerLogger } from '../logger';
+import { Log, RootLogger } from '../logger';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
@@ -44,7 +44,6 @@ const browserStdErrLog: Log = {
   severity: 'warning'
 };
 
-
 export type LaunchProcessOptions = {
   executablePath: string,
   args: string[],
@@ -62,7 +61,7 @@ export type LaunchProcessOptions = {
   // Note: attemptToGracefullyClose should reject if it does not close the browser.
   attemptToGracefullyClose: () => Promise<any>,
   onkill: (exitCode: number | null, signal: string | null) => void,
-  logger: InnerLogger,
+  logger: RootLogger,
 };
 
 type LaunchResult = {
@@ -74,6 +73,7 @@ type LaunchResult = {
 export async function launchProcess(options: LaunchProcessOptions): Promise<LaunchResult> {
   const logger = options.logger;
   const stdio: ('ignore' | 'pipe')[] = options.pipe ? ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'];
+  logger.startLaunchRecording();
   logger._log(browserLog, `<launching> ${options.executablePath} ${options.args.join(' ')}`);
   const spawnedProcess = childProcess.spawn(
       options.executablePath,

src/server/webkit.ts

@@ -33,7 +33,6 @@ import { Events } from '../events';
 import { BrowserContext } from '../browserContext';
 import { InnerLogger, logError, RootLogger } from '../logger';
 import { BrowserDescriptor } from '../install/browserPaths';
-import { TimeoutSettings } from '../timeoutSettings';
 
 export class WebKit extends AbstractBrowserType<WKBrowser> {
   constructor(packagePath: string, browser: BrowserDescriptor) {
@@ -42,16 +41,13 @@ export class WebKit extends AbstractBrowserType<WKBrowser> {
 
   async launch(options: LaunchOptions = {}): Promise<WKBrowser> {
     assert(!(options as any).userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
-    const { timeout = 30000 } = options;
+    const browserServer = new BrowserServer(options);
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const { transport, downloadsPath } = await this._launchServer(options, 'local', browserServer);
-    const { browserServer, transport, downloadsPath, logger } = await this._launchServer(options, 'local');
+    return await browserServer._initializeOrClose(async () => {
-    return await browserServer._initializeOrClose(deadline, async () => {
-      if ((options as any).__testHookBeforeCreateBrowser)
-        await (options as any).__testHookBeforeCreateBrowser();
       return await WKBrowser.connect(transport!, {
         slowMo: options.slowMo,
         headful: !processBrowserArgOptions(options).headless,
-        logger,
+        logger: browserServer._logger,
         downloadsPath,
         ownedServer: browserServer
       });
@@ -59,20 +55,19 @@ export class WebKit extends AbstractBrowserType<WKBrowser> {
   }
 
   async launchServer(options: LaunchServerOptions = {}): Promise<BrowserServer> {
-    return (await this._launchServer(options, 'server')).browserServer;
+    const browserServer = new BrowserServer(options);
+    await this._launchServer(options, 'server', browserServer);
+    return browserServer;
   }
 
   async launchPersistentContext(userDataDir: string, options: LaunchOptions = {}): Promise<BrowserContext> {
-    const { timeout = 30000 } = options;
+    const browserServer = new BrowserServer(options);
-    const deadline = TimeoutSettings.computeDeadline(timeout);
+    const { transport, downloadsPath } = await this._launchServer(options, 'persistent', browserServer, userDataDir);
-    const { transport, browserServer, logger, downloadsPath } = await this._launchServer(options, 'persistent', userDataDir);
+    return await browserServer._initializeOrClose(async () => {
-    return await browserServer._initializeOrClose(deadline, async () => {
-      if ((options as any).__testHookBeforeCreateBrowser)
-        await (options as any).__testHookBeforeCreateBrowser();
       const browser = await WKBrowser.connect(transport!, {
         slowMo: options.slowMo,
         headful: !processBrowserArgOptions(options).headless,
-        logger,
+        logger: browserServer._logger,
         persistent: true,
         downloadsPath,
         ownedServer: browserServer
@@ -84,7 +79,7 @@ export class WebKit extends AbstractBrowserType<WKBrowser> {
     });
   }
 
-  private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, userDataDir?: string): Promise<{ browserServer: BrowserServer, transport?: ConnectionTransport, downloadsPath: string, logger: InnerLogger }> {
+  private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, browserServer: BrowserServer, userDataDir?: string): Promise<{ transport?: ConnectionTransport, downloadsPath: string, logger: RootLogger }> {
     const {
       ignoreDefaultArgs = false,
       args = [],
@@ -96,7 +91,7 @@ export class WebKit extends AbstractBrowserType<WKBrowser> {
       port = 0,
     } = options;
     assert(!port || launchType === 'server', 'Cannot specify a port without launching as a server.');
-    const logger = new RootLogger(options.logger);
+    const logger = browserServer._logger;
 
     let temporaryUserDataDir: string | null = null;
     if (!userDataDir) {
@@ -119,7 +114,6 @@ export class WebKit extends AbstractBrowserType<WKBrowser> {
     // Note: it is important to define these variables before launchProcess, so that we don't get
     // "Cannot access 'browserServer' before initialization" if something went wrong.
     let transport: ConnectionTransport | undefined = undefined;
-    let browserServer: BrowserServer | undefined = undefined;
     const { launchedProcess, gracefullyClose, downloadsPath } = await launchProcess({
       executablePath: webkitExecutable,
       args: webkitArguments,
@@ -135,18 +129,17 @@ export class WebKit extends AbstractBrowserType<WKBrowser> {
         // We try to gracefully close to prevent crash reporting and core dumps.
         // Note that it's fine to reuse the pipe transport, since
         // our connection ignores kBrowserCloseMessageId.
-        await transport.send({method: 'Playwright.close', params: {}, id: kBrowserCloseMessageId});
+        transport.send({method: 'Playwright.close', params: {}, id: kBrowserCloseMessageId});
       },
       onkill: (exitCode, signal) => {
-        if (browserServer)
+        browserServer.emit(Events.BrowserServer.Close, exitCode, signal);
-          browserServer.emit(Events.BrowserServer.Close, exitCode, signal);
       },
     });
 
     const stdio = launchedProcess.stdio as unknown as [NodeJS.ReadableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.ReadableStream];
     transport = new PipeTransport(stdio[3], stdio[4], logger);
-    browserServer = new BrowserServer(launchedProcess, gracefullyClose, launchType === 'server' ? wrapTransportWithWebSocket(transport, logger, port || 0) : null);
+    browserServer._initialize(launchedProcess, gracefullyClose, launchType === 'server' ? wrapTransportWithWebSocket(transport, logger, port || 0) : null);
-    return { browserServer, transport, downloadsPath, logger };
+    return { transport, downloadsPath, logger };
   }
 
   async connect(options: ConnectOptions): Promise<WKBrowser> {

src/webkit/wkBrowser.ts

@@ -39,6 +39,7 @@ export class WKBrowser extends BrowserBase {
 
   static async connect(transport: ConnectionTransport, options: BrowserOptions): Promise<WKBrowser> {
     const browser = new WKBrowser(SlowMoTransport.wrap(transport, options.slowMo), options);
+    // TODO: add Playwright.enable to test connection.
     return browser;
   }
 

test/launcher.spec.js

@@ -54,7 +54,7 @@ describe('Playwright', function() {
     it('should handle timeout', async({browserType, defaultBrowserOptions}) => {
       const options = { ...defaultBrowserOptions, timeout: 5000, __testHookBeforeCreateBrowser: () => new Promise(f => setTimeout(f, 6000)) };
       const error = await browserType.launch(options).catch(e => e);
-      expect(error.message).toBe('Waiting for the browser to launch failed: timeout exceeded. Re-run with the DEBUG=pw:browser* env variable to see the debug log.');
+      expect(error.message).toContain('Waiting for the browser to launch failed: timeout exceeded. Re-run with the DEBUG=pw:browser* env variable to see the debug log.');
     });
     it('should handle exception', async({browserType, defaultBrowserOptions}) => {
       const e = new Error('Dummy');
@@ -62,6 +62,12 @@ describe('Playwright', function() {
       const error = await browserType.launch(options).catch(e => e);
       expect(error).toBe(e);
     });
+    it('should report launch log', async({browserType, defaultBrowserOptions}) => {
+      const e = new Error('Dummy');
+      const options = { ...defaultBrowserOptions, __testHookBeforeCreateBrowser: () => { throw e; }, timeout: 9000 };
+      const error = await browserType.launch(options).catch(e => e);
+      expect(error.message).toContain('<launching>');
+    });
   });
 
   describe('browserType.launchPersistentContext', function() {
@@ -102,7 +108,7 @@ describe('Playwright', function() {
       const userDataDir = await makeUserDataDir();
       const options = { ...defaultBrowserOptions, timeout: 5000, __testHookBeforeCreateBrowser: () => new Promise(f => setTimeout(f, 6000)) };
       const error = await browserType.launchPersistentContext(userDataDir, options).catch(e => e);
-      expect(error.message).toBe('Waiting for the browser to launch failed: timeout exceeded. Re-run with the DEBUG=pw:browser* env variable to see the debug log.');
+      expect(error.message).toContain('Waiting for the browser to launch failed: timeout exceeded. Re-run with the DEBUG=pw:browser* env variable to see the debug log.');
       await removeUserDataDir(userDataDir);
     });
     it('should handle exception', async({browserType, defaultBrowserOptions}) => {

utils/doclint/check_public_api/index.js

@@ -213,7 +213,7 @@ function compareDocumentations(actual, expected) {
     let expectedName = expected.name;
     for (const replacer of tsReplacers)
       expectedName = expectedName.replace(...replacer);
-    if (expectedName !== actualName)
+    if (normalizeType(expectedName) !== normalizeType(actualName))
       errors.push(`${source} ${actualName} != ${expectedName}`);
     if (actual.name === 'boolean' || actual.name === 'string')
       return;
@@ -304,3 +304,23 @@ function diff(actual, expected) {
   }
 }
 
+function normalizeType(type) {
+  let nesting = 0;
+  const result = [];
+  let word = '';
+  for (const c of type) {
+    if (c === '<') {
+      ++nesting;
+    } else if (c === '>') {
+      --nesting;
+    }
+    if (c === '|' && !nesting) {
+      result.push(word);
+      word = '';
+    } else {
+      word += c;
+    }
+  }
+  result.sort();
+  return result.join('|');
+}