fix(api): BrowserServer -> BrowserApp, resuse it between browsers (#599)

Author: dgozman

docs/api.md

@@ -36,6 +36,7 @@ export { FFBrowser as FirefoxBrowser } from './firefox/ffBrowser';
 export { WKBrowser as WebKitBrowser } from './webkit/wkBrowser';
 
 export { Playwright } from './server/playwright';
-export { CRPlaywright as ChromiumPlaywright, CRBrowserServer as ChromiumBrowserServer } from './server/crPlaywright';
-export { FFPlaywright as FirefoxPlaywright, FFBrowserServer as FirefoxBrowserServer } from './server/ffPlaywright';
-export { WKPlaywright as WebKitPlaywright, WKBrowserServer as WebKitBrowserServer } from './server/wkPlaywright';
+export { BrowserApp } from './server/browserApp';
+export { CRPlaywright as ChromiumPlaywright } from './server/crPlaywright';
+export { FFPlaywright as FirefoxPlaywright } from './server/ffPlaywright';
+export { WKPlaywright as WebKitPlaywright } from './server/wkPlaywright';

src/api.ts

@@ -15,7 +15,9 @@
  */
 
 import { BrowserContext, BrowserContextOptions } from './browserContext';
+import { ConnectionTransport, SlowMoTransport } from './transport';
 import * as platform from './platform';
+import { assert } from './helper';
 
 export interface Browser extends platform.EventEmitterType {
   newContext(options?: BrowserContextOptions): Promise<BrowserContext>;
@@ -26,3 +28,19 @@ export interface Browser extends platform.EventEmitterType {
   isConnected(): boolean;
   close(): Promise<void>;
 }
+
+export type ConnectOptions = {
+  slowMo?: number,
+  browserWSEndpoint?: string;
+  transport?: ConnectionTransport;
+};
+
+export async function createTransport(options: ConnectOptions): Promise<ConnectionTransport> {
+  assert(Number(!!options.browserWSEndpoint) + Number(!!options.transport) === 1, 'Exactly one of browserWSEndpoint or transport must be passed to connect');
+  let transport: ConnectionTransport | undefined;
+  if (options.transport)
+    transport = options.transport;
+  else if (options.browserWSEndpoint)
+    transport = await platform.createWebSocketTransport(options.browserWSEndpoint);
+  return SlowMoTransport.wrap(transport!, options.slowMo);
+}

src/browser.ts

@@ -24,20 +24,12 @@ import { Page, Worker } from '../page';
 import { CRTarget } from './crTarget';
 import { Protocol } from './protocol';
 import { CRPage } from './crPage';
-import { Browser } from '../browser';
+import { Browser, createTransport, ConnectOptions } from '../browser';
 import * as network from '../network';
 import * as types from '../types';
 import * as platform from '../platform';
-import { ConnectionTransport, SlowMoTransport } from '../transport';
 import { readProtocolStream } from './crProtocolHelper';
 
-export type CRConnectOptions = {
-  slowMo?: number,
-  browserWSEndpoint?: string;
-  browserURL?: string;
-  transport?: ConnectionTransport;
-};
-
 export class CRBrowser extends platform.EventEmitter implements Browser {
   _connection: CRConnection;
   _client: CRSession;
@@ -49,7 +41,7 @@ export class CRBrowser extends platform.EventEmitter implements Browser {
   private _tracingPath: string | null = '';
   private _tracingClient: CRSession | undefined;
 
-  static async connect(options: CRConnectOptions): Promise<CRBrowser> {
+  static async connect(options: ConnectOptions): Promise<CRBrowser> {
     const transport = await createTransport(options);
     const connection = new CRConnection(transport);
     const { browserContextIds } = await connection.rootSession.send('Target.getBrowserContexts');
@@ -309,24 +301,3 @@ export class CRBrowser extends platform.EventEmitter implements Browser {
     return !this._connection._closed;
   }
 }
-
-export async function createTransport(options: CRConnectOptions): Promise<ConnectionTransport> {
-  assert(Number(!!options.browserWSEndpoint) + Number(!!options.browserURL) + Number(!!options.transport) === 1, 'Exactly one of browserWSEndpoint, browserURL or transport must be passed to connect');
-  let transport: ConnectionTransport | undefined;
-  if (options.transport) {
-    transport = options.transport;
-  } else if (options.browserWSEndpoint) {
-    transport = await platform.createWebSocketTransport(options.browserWSEndpoint);
-  } else if (options.browserURL) {
-    let connectionURL: string;
-    try {
-      const data = await platform.fetchUrl(new URL('/json/version', options.browserURL).href);
-      connectionURL = JSON.parse(data).webSocketDebuggerUrl;
-    } catch (e) {
-      e.message = `Failed to fetch browser webSocket url from ${options.browserURL}: ` + e.message;
-      throw e;
-    }
-    transport = await platform.createWebSocketTransport(connectionURL);
-  }
-  return SlowMoTransport.wrap(transport!, options.slowMo);
-}

src/chromium/crBrowser.ts

@@ -15,33 +15,26 @@
  * limitations under the License.
  */
 
-import { Browser } from '../browser';
+import { Browser, createTransport, ConnectOptions } from '../browser';
 import { BrowserContext, BrowserContextOptions } from '../browserContext';
 import { Events } from '../events';
 import { assert, helper, RegisteredListener } from '../helper';
 import * as network from '../network';
 import * as types from '../types';
 import { Page } from '../page';
-import { ConnectionTransport, SlowMoTransport } from '../transport';
 import { ConnectionEvents, FFConnection, FFSessionEvents } from './ffConnection';
 import { FFPage } from './ffPage';
 import * as platform from '../platform';
 import { Protocol } from './protocol';
 
-export type FFConnectOptions = {
-  slowMo?: number,
-  browserWSEndpoint?: string;
-  transport?: ConnectionTransport;
-};
-
 export class FFBrowser extends platform.EventEmitter implements Browser {
   _connection: FFConnection;
   _targets: Map<string, Target>;
   private _defaultContext: BrowserContext;
   private _contexts: Map<string, BrowserContext>;
   private _eventListeners: RegisteredListener[];
 
-  static async connect(options: FFConnectOptions): Promise<FFBrowser> {
+  static async connect(options: ConnectOptions): Promise<FFBrowser> {
     const transport = await createTransport(options);
     const connection = new FFConnection(transport);
     const {browserContextIds} = await connection.send('Target.getBrowserContexts');
@@ -292,13 +285,3 @@ class Target {
     return this._browser;
   }
 }
-
-export async function createTransport(options: FFConnectOptions): Promise<ConnectionTransport> {
-  assert(Number(!!options.browserWSEndpoint) + Number(!!options.transport) === 1, 'Exactly one of browserWSEndpoint or transport must be passed to connect');
-  let transport: ConnectionTransport | undefined;
-  if (options.transport)
-    transport = options.transport;
-  else if (options.browserWSEndpoint)
-    transport = await platform.createWebSocketTransport(options.browserWSEndpoint);
-  return SlowMoTransport.wrap(transport!, options.slowMo);
-}

src/firefox/ffBrowser.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { ChildProcess } from 'child_process';
+import { ConnectOptions } from '../browser';
+
+export class BrowserApp {
+  private _process: ChildProcess;
+  private _gracefullyClose: () => Promise<void>;
+  private _connectOptions: ConnectOptions;
+
+  constructor(process: ChildProcess, gracefullyClose: () => Promise<void>, connectOptions: ConnectOptions) {
+    this._process = process;
+    this._gracefullyClose = gracefullyClose;
+    this._connectOptions = connectOptions;
+  }
+
+  process(): ChildProcess {
+    return this._process;
+  }
+
+  wsEndpoint(): string | null {
+    return this._connectOptions.browserWSEndpoint || null;
+  }
+
+  connectOptions(): ConnectOptions {
+    return this._connectOptions;
+  }
+
+  async close(): Promise<void> {
+    await this._gracefullyClose();
+  }
+}

src/server/browserApp.ts

@@ -23,14 +23,15 @@ import { BrowserFetcher, BrowserFetcherOptions } from '../server/browserFetcher'
 import { DeviceDescriptors } from '../deviceDescriptors';
 import * as types from '../types';
 import { assert } from '../helper';
-import { CRBrowser, CRConnectOptions, createTransport } from '../chromium/crBrowser';
+import { CRBrowser } from '../chromium/crBrowser';
 import * as platform from '../platform';
 import { TimeoutError } from '../errors';
 import { launchProcess, waitForLine } from '../server/processLauncher';
-import { ChildProcess } from 'child_process';
 import { CRConnection } from '../chromium/crConnection';
 import { PipeTransport } from './pipeTransport';
 import { Playwright } from './playwright';
+import { createTransport, ConnectOptions } from '../browser';
+import { BrowserApp } from './browserApp';
 
 export type SlowMoOptions = {
   slowMo?: number,
@@ -55,34 +56,6 @@ export type LaunchOptions = ChromiumArgOptions & SlowMoOptions & {
   pipe?: boolean,
 };
 
-export class CRBrowserServer {
-  private _process: ChildProcess;
-  private _gracefullyClose: () => Promise<void>;
-  private _connectOptions: CRConnectOptions;
-
-  constructor(process: ChildProcess, gracefullyClose: () => Promise<void>, connectOptions: CRConnectOptions) {
-    this._process = process;
-    this._gracefullyClose = gracefullyClose;
-    this._connectOptions = connectOptions;
-  }
-
-  process(): ChildProcess {
-    return this._process;
-  }
-
-  wsEndpoint(): string | null {
-    return this._connectOptions.browserWSEndpoint || null;
-  }
-
-  connectOptions(): CRConnectOptions {
-    return this._connectOptions;
-  }
-
-  async close(): Promise<void> {
-    await this._gracefullyClose();
-  }
-}
-
 export class CRPlaywright implements Playwright {
   private _projectRoot: string;
   readonly _revision: string;
@@ -93,14 +66,14 @@ export class CRPlaywright implements Playwright {
   }
 
   async launch(options?: LaunchOptions): Promise<CRBrowser> {
-    const server = await this.launchServer(options);
-    const browser = await CRBrowser.connect(server.connectOptions());
+    const app = await this.launchBrowserApp(options);
+    const browser = await CRBrowser.connect(app.connectOptions());
     // Hack: for typical launch scenario, ensure that close waits for actual process termination.
-    browser.close = () => server.close();
+    browser.close = () => app.close();
     return browser;
   }
 
-  async launchServer(options: LaunchOptions = {}): Promise<CRBrowserServer> {
+  async launchBrowserApp(options: LaunchOptions = {}): Promise<BrowserApp> {
     const {
       ignoreDefaultArgs = false,
       args = [],
@@ -165,7 +138,7 @@ export class CRPlaywright implements Playwright {
       },
     });
 
-    let connectOptions: CRConnectOptions | undefined;
+    let connectOptions: ConnectOptions | undefined;
     if (!usePipe) {
       const timeoutError = new TimeoutError(`Timed out after ${timeout} ms while trying to connect to Chromium! The only Chromium revision guaranteed to work is r${this._revision}`);
       const match = await waitForLine(launchedProcess, launchedProcess.stderr, /^DevTools listening on (ws:\/\/.*)$/, timeout, timeoutError);
@@ -175,10 +148,23 @@ export class CRPlaywright implements Playwright {
       const transport = new PipeTransport(launchedProcess.stdio[3] as NodeJS.WritableStream, launchedProcess.stdio[4] as NodeJS.ReadableStream);
       connectOptions = { slowMo, transport };
     }
-    return new CRBrowserServer(launchedProcess, gracefullyClose, connectOptions);
+    return new BrowserApp(launchedProcess, gracefullyClose, connectOptions);
   }
 
-  async connect(options: CRConnectOptions): Promise<CRBrowser> {
+  async connect(options: ConnectOptions & { browserURL?: string }): Promise<CRBrowser> {
+    if (options.browserURL) {
+      assert(!options.browserWSEndpoint && !options.transport, 'Exactly one of browserWSEndpoint, browserURL or transport must be passed to connect');
+      let connectionURL: string;
+      try {
+        const data = await platform.fetchUrl(new URL('/json/version', options.browserURL).href);
+        connectionURL = JSON.parse(data).webSocketDebuggerUrl;
+      } catch (e) {
+        e.message = `Failed to fetch browser webSocket url from ${options.browserURL}: ` + e.message;
+        throw e;
+      }
+      const transport = await platform.createWebSocketTransport(connectionURL);
+      options = { ...options, transport };
+    }
     return CRBrowser.connect(options);
   }