third_party/devtools/node_modules/puppeteer/lib/Launcher.js - cobalt - Git at Google

 /**
  * Copyright 2017 Google Inc. All rights reserved.
  *
  * 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.
  */
 const os = require('os');
 const path = require('path');
 const http = require('http');
 const https = require('https');
 const URL = require('url');
 const removeFolder = require('rimraf');
 const childProcess = require('child_process');
 const BrowserFetcher = require('./BrowserFetcher');
 const {Connection} = require('./Connection');
 const {Browser} = require('./Browser');
 const readline = require('readline');
 const fs = require('fs');
 const {helper, assert, debugError} = require('./helper');
 const {TimeoutError} = require('./Errors');
 const WebSocketTransport = require('./WebSocketTransport');
 const PipeTransport = require('./PipeTransport');

 const mkdtempAsync = helper.promisify(fs.mkdtemp);
 const removeFolderAsync = helper.promisify(removeFolder);

 const CHROME_PROFILE_PATH = path.join(os.tmpdir(), 'puppeteer_dev_profile-');

 const DEFAULT_ARGS = [
   '--disable-background-networking',
   '--enable-features=NetworkService,NetworkServiceInProcess',
   '--disable-background-timer-throttling',
   '--disable-backgrounding-occluded-windows',
   '--disable-breakpad',
   '--disable-client-side-phishing-detection',
   '--disable-component-extensions-with-background-pages',
   '--disable-default-apps',
   '--disable-dev-shm-usage',
   '--disable-extensions',
   // BlinkGenPropertyTrees disabled due to crbug.com/937609
   '--disable-features=TranslateUI,BlinkGenPropertyTrees',
   '--disable-hang-monitor',
   '--disable-ipc-flooding-protection',
   '--disable-popup-blocking',
   '--disable-prompt-on-repost',
   '--disable-renderer-backgrounding',
   '--disable-sync',
   '--force-color-profile=srgb',
   '--metrics-recording-only',
   '--no-first-run',
   '--enable-automation',
   '--password-store=basic',
   '--use-mock-keychain',
 ];

 class Launcher {
   /**
    * @param {string} projectRoot
    * @param {string} preferredRevision
    * @param {boolean} isPuppeteerCore
    */
   constructor(projectRoot, preferredRevision, isPuppeteerCore) {
     this._projectRoot = projectRoot;
     this._preferredRevision = preferredRevision;
     this._isPuppeteerCore = isPuppeteerCore;
   }

   /**
    * @param {!(Launcher.LaunchOptions & Launcher.ChromeArgOptions & Launcher.BrowserOptions)=} options
    * @return {!Promise<!Browser>}
    */
   async launch(options = {}) {
     const {
       ignoreDefaultArgs = false,
       args = [],
       dumpio = false,
       executablePath = null,
       pipe = false,
       env = process.env,
       handleSIGINT = true,
       handleSIGTERM = true,
       handleSIGHUP = true,
       ignoreHTTPSErrors = false,
       defaultViewport = {width: 800, height: 600},
       slowMo = 0,
       timeout = 30000
     } = options;

     const chromeArguments = [];
     if (!ignoreDefaultArgs)
       chromeArguments.push(...this.defaultArgs(options));
     else if (Array.isArray(ignoreDefaultArgs))
       chromeArguments.push(...this.defaultArgs(options).filter(arg => ignoreDefaultArgs.indexOf(arg) === -1));
     else
       chromeArguments.push(...args);

     let temporaryUserDataDir = null;

     if (!chromeArguments.some(argument => argument.startsWith('--remote-debugging-')))
       chromeArguments.push(pipe ? '--remote-debugging-pipe' : '--remote-debugging-port=0');
     if (!chromeArguments.some(arg => arg.startsWith('--user-data-dir'))) {
       temporaryUserDataDir = await mkdtempAsync(CHROME_PROFILE_PATH);
       chromeArguments.push(`--user-data-dir=${temporaryUserDataDir}`);
     }

     let chromeExecutable = executablePath;
     if (!executablePath) {
       const {missingText, executablePath} = this._resolveExecutablePath();
       if (missingText)
         throw new Error(missingText);
       chromeExecutable = executablePath;
     }

     const usePipe = chromeArguments.includes('--remote-debugging-pipe');
     /** @type {!Array<"ignore"|"pipe">} */
     let stdio = ['pipe', 'pipe', 'pipe'];
     if (usePipe) {
       if (dumpio)
         stdio = ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'];
       else
         stdio = ['ignore', 'ignore', 'ignore', 'pipe', 'pipe'];
     }
     const chromeProcess = childProcess.spawn(
         chromeExecutable,
         chromeArguments,
         {
           // On non-windows platforms, `detached: true` makes child process a leader of a new
           // process group, making it possible to kill child process tree with `.kill(-pid)` command.
           // @see https://nodejs.org/api/child_process.html#child_process_options_detached
           detached: process.platform !== 'win32',
           env,
           stdio
         }
     );

     if (dumpio) {
       chromeProcess.stderr.pipe(process.stderr);
       chromeProcess.stdout.pipe(process.stdout);
     }

     let chromeClosed = false;
     const waitForChromeToClose = new Promise((fulfill, reject) => {
       chromeProcess.once('exit', () => {
         chromeClosed = true;
         // Cleanup as processes exit.
         if (temporaryUserDataDir) {
           removeFolderAsync(temporaryUserDataDir)
               .then(() => fulfill())
               .catch(err => console.error(err));
         } else {
           fulfill();
         }
       });
     });

     const listeners = [ helper.addEventListener(process, 'exit', killChrome) ];
     if (handleSIGINT)
       listeners.push(helper.addEventListener(process, 'SIGINT', () => { killChrome(); process.exit(130); }));
     if (handleSIGTERM)
       listeners.push(helper.addEventListener(process, 'SIGTERM', gracefullyCloseChrome));
     if (handleSIGHUP)
       listeners.push(helper.addEventListener(process, 'SIGHUP', gracefullyCloseChrome));
     /** @type {?Connection} */
     let connection = null;
     try {
       if (!usePipe) {
         const browserWSEndpoint = await waitForWSEndpoint(chromeProcess, timeout, this._preferredRevision);
         const transport = await WebSocketTransport.create(browserWSEndpoint);
         connection = new Connection(browserWSEndpoint, transport, slowMo);
       } else {
         const transport = new PipeTransport(/** @type {!NodeJS.WritableStream} */(chromeProcess.stdio[3]), /** @type {!NodeJS.ReadableStream} */ (chromeProcess.stdio[4]));
         connection = new Connection('', transport, slowMo);
       }
       const browser = await Browser.create(connection, [], ignoreHTTPSErrors, defaultViewport, chromeProcess, gracefullyCloseChrome);
       await browser.waitForTarget(t => t.type() === 'page');
       return browser;
     } catch (e) {
       killChrome();
       throw e;
     }

     /**
      * @return {Promise}
      */
     function gracefullyCloseChrome() {
       helper.removeEventListeners(listeners);
       if (temporaryUserDataDir) {
         killChrome();
       } else if (connection) {
         // Attempt to close chrome gracefully
         connection.send('Browser.close').catch(error => {
           debugError(error);
           killChrome();
         });
       }
       return waitForChromeToClose;
     }

     // This method has to be sync to be used as 'exit' event handler.
     function killChrome() {
       helper.removeEventListeners(listeners);
       if (chromeProcess.pid && !chromeProcess.killed && !chromeClosed) {
         // Force kill chrome.
         try {
           if (process.platform === 'win32')
             childProcess.execSync(`taskkill /pid ${chromeProcess.pid} /T /F`);
           else
             process.kill(-chromeProcess.pid, 'SIGKILL');
         } catch (e) {
           // the process might have already stopped
         }
       }
       // Attempt to remove temporary profile directory to avoid littering.
       try {
         removeFolder.sync(temporaryUserDataDir);
       } catch (e) { }
     }
   }

   /**
    * @param {!Launcher.ChromeArgOptions=} options
    * @return {!Array<string>}
    */
   defaultArgs(options = {}) {
     const {
       devtools = false,
       headless = !devtools,
       args = [],
       userDataDir = null
     } = options;
     const chromeArguments = [...DEFAULT_ARGS];
     if (userDataDir)
       chromeArguments.push(`--user-data-dir=${userDataDir}`);
     if (devtools)
       chromeArguments.push('--auto-open-devtools-for-tabs');
     if (headless) {
       chromeArguments.push(
           '--headless',
           '--hide-scrollbars',
           '--mute-audio'
       );
     }
     if (args.every(arg => arg.startsWith('-')))
       chromeArguments.push('about:blank');
     chromeArguments.push(...args);
     return chromeArguments;
   }

   /**
    * @return {string}
    */
   executablePath() {
     return this._resolveExecutablePath().executablePath;
   }

   /**
    * @param {!(Launcher.BrowserOptions & {browserWSEndpoint?: string, browserURL?: string, transport?: !Puppeteer.ConnectionTransport})} options
    * @return {!Promise<!Browser>}
    */
   async connect(options) {
     const {
       browserWSEndpoint,
       browserURL,
       ignoreHTTPSErrors = false,
       defaultViewport = {width: 800, height: 600},
       transport,
       slowMo = 0,
     } = options;

     assert(Number(!!browserWSEndpoint) + Number(!!browserURL) + Number(!!transport) === 1, 'Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect');

     let connection = null;
     if (transport) {
       connection = new Connection('', transport, slowMo);
     } else if (browserWSEndpoint) {
       const connectionTransport = await WebSocketTransport.create(browserWSEndpoint);
       connection = new Connection(browserWSEndpoint, connectionTransport, slowMo);
     } else if (browserURL) {
       const connectionURL = await getWSEndpoint(browserURL);
       const connectionTransport = await WebSocketTransport.create(connectionURL);
       connection = new Connection(connectionURL, connectionTransport, slowMo);
     }

     const {browserContextIds} = await connection.send('Target.getBrowserContexts');
     return Browser.create(connection, browserContextIds, ignoreHTTPSErrors, defaultViewport, null, () => connection.send('Browser.close').catch(debugError));
   }

   /**
    * @return {{executablePath: string, missingText: ?string}}
    */
   _resolveExecutablePath() {
     // puppeteer-core doesn't take into account PUPPETEER_* env variables.
     if (!this._isPuppeteerCore) {
       const executablePath = process.env.PUPPETEER_EXECUTABLE_PATH || process.env.npm_config_puppeteer_executable_path || process.env.npm_package_config_puppeteer_executable_path;
       if (executablePath) {
         const missingText = !fs.existsSync(executablePath) ? 'Tried to use PUPPETEER_EXECUTABLE_PATH env variable to launch browser but did not find any executable at: ' + executablePath : null;
         return { executablePath, missingText };
       }
     }
     const browserFetcher = new BrowserFetcher(this._projectRoot);
     if (!this._isPuppeteerCore) {
       const revision = process.env['PUPPETEER_CHROMIUM_REVISION'];
       if (revision) {
         const revisionInfo = browserFetcher.revisionInfo(revision);
         const missingText = !revisionInfo.local ? 'Tried to use PUPPETEER_CHROMIUM_REVISION env variable to launch browser but did not find executable at: ' + revisionInfo.executablePath : null;
         return {executablePath: revisionInfo.executablePath, missingText};
       }
     }
     const revisionInfo = browserFetcher.revisionInfo(this._preferredRevision);
     const missingText = !revisionInfo.local ? `Chromium revision is not downloaded. Run "npm install" or "yarn install"` : null;
     return {executablePath: revisionInfo.executablePath, missingText};
   }

 }

 /**
  * @param {!Puppeteer.ChildProcess} chromeProcess
  * @param {number} timeout
  * @param {string} preferredRevision
  * @return {!Promise<string>}
  */
 function waitForWSEndpoint(chromeProcess, timeout, preferredRevision) {
   return new Promise((resolve, reject) => {
     const rl = readline.createInterface({ input: chromeProcess.stderr });
     let stderr = '';
     const listeners = [
       helper.addEventListener(rl, 'line', onLine),
       helper.addEventListener(rl, 'close', () => onClose()),
       helper.addEventListener(chromeProcess, 'exit', () => onClose()),
       helper.addEventListener(chromeProcess, 'error', error => onClose(error))
     ];
     const timeoutId = timeout ? setTimeout(onTimeout, timeout) : 0;

     /**
      * @param {!Error=} error
      */
     function onClose(error) {
       cleanup();
       reject(new Error([
         'Failed to launch chrome!' + (error ? ' ' + error.message : ''),
         stderr,
         '',
         'TROUBLESHOOTING: https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md',
         '',
       ].join('\n')));
     }

     function onTimeout() {
       cleanup();
       reject(new TimeoutError(`Timed out after ${timeout} ms while trying to connect to Chrome! The only Chrome revision guaranteed to work is r${preferredRevision}`));
     }

     /**
      * @param {string} line
      */
     function onLine(line) {
       stderr += line + '\n';
       const match = line.match(/^DevTools listening on (ws:\/\/.*)$/);
       if (!match)
         return;
       cleanup();
       resolve(match[1]);
     }

     function cleanup() {
       if (timeoutId)
         clearTimeout(timeoutId);
       helper.removeEventListeners(listeners);
     }
   });
 }

 /**
  * @param {string} browserURL
  * @return {!Promise<string>}
  */
 function getWSEndpoint(browserURL) {
   let resolve, reject;
   const promise = new Promise((res, rej) => { resolve = res; reject = rej; });

   const endpointURL = URL.resolve(browserURL, '/json/version');
   const protocol = endpointURL.startsWith('https') ? https : http;
   const requestOptions = Object.assign(URL.parse(endpointURL), { method: 'GET' });
   const request = protocol.request(requestOptions, res => {
     let data = '';
     if (res.statusCode !== 200) {
       // Consume response data to free up memory.
       res.resume();
       reject(new Error('HTTP ' + res.statusCode));
       return;
     }
     res.setEncoding('utf8');
     res.on('data', chunk => data += chunk);
     res.on('end', () => resolve(JSON.parse(data).webSocketDebuggerUrl));
   });

   request.on('error', reject);
   request.end();

   return promise.catch(e => {
     e.message = `Failed to fetch browser webSocket url from ${endpointURL}: ` + e.message;
     throw e;
   });
 }

 /**
  * @typedef {Object} Launcher.ChromeArgOptions
  * @property {boolean=} headless
  * @property {Array<string>=} args
  * @property {string=} userDataDir
  * @property {boolean=} devtools
  */

 /**
  * @typedef {Object} Launcher.LaunchOptions
  * @property {string=} executablePath
  * @property {boolean|Array<string>=} ignoreDefaultArgs
  * @property {boolean=} handleSIGINT
  * @property {boolean=} handleSIGTERM
  * @property {boolean=} handleSIGHUP
  * @property {number=} timeout
  * @property {boolean=} dumpio
  * @property {!Object<string, string | undefined>=} env
  * @property {boolean=} pipe
  */

 /**
  * @typedef {Object} Launcher.BrowserOptions
  * @property {boolean=} ignoreHTTPSErrors
  * @property {(?Puppeteer.Viewport)=} defaultViewport
  * @property {number=} slowMo
  */


 module.exports = Launcher;
	/**
	* Copyright 2017 Google Inc. All rights reserved.
	*
	* 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.
	*/
	const os = require('os');
	const path = require('path');
	const http = require('http');
	const https = require('https');
	const URL = require('url');
	const removeFolder = require('rimraf');
	const childProcess = require('child_process');
	const BrowserFetcher = require('./BrowserFetcher');
	const {Connection} = require('./Connection');
	const {Browser} = require('./Browser');
	const readline = require('readline');
	const fs = require('fs');
	const {helper, assert, debugError} = require('./helper');
	const {TimeoutError} = require('./Errors');
	const WebSocketTransport = require('./WebSocketTransport');
	const PipeTransport = require('./PipeTransport');

	const mkdtempAsync = helper.promisify(fs.mkdtemp);
	const removeFolderAsync = helper.promisify(removeFolder);

	const CHROME_PROFILE_PATH = path.join(os.tmpdir(), 'puppeteer_dev_profile-');

	const DEFAULT_ARGS = [
	'--disable-background-networking',
	'--enable-features=NetworkService,NetworkServiceInProcess',
	'--disable-background-timer-throttling',
	'--disable-backgrounding-occluded-windows',
	'--disable-breakpad',
	'--disable-client-side-phishing-detection',
	'--disable-component-extensions-with-background-pages',
	'--disable-default-apps',
	'--disable-dev-shm-usage',
	'--disable-extensions',
	// BlinkGenPropertyTrees disabled due to crbug.com/937609
	'--disable-features=TranslateUI,BlinkGenPropertyTrees',
	'--disable-hang-monitor',
	'--disable-ipc-flooding-protection',
	'--disable-popup-blocking',
	'--disable-prompt-on-repost',
	'--disable-renderer-backgrounding',
	'--disable-sync',
	'--force-color-profile=srgb',
	'--metrics-recording-only',
	'--no-first-run',
	'--enable-automation',
	'--password-store=basic',
	'--use-mock-keychain',
	];

	class Launcher {
	/**
	* @param {string} projectRoot
	* @param {string} preferredRevision
	* @param {boolean} isPuppeteerCore
	*/
	constructor(projectRoot, preferredRevision, isPuppeteerCore) {
	this._projectRoot = projectRoot;
	this._preferredRevision = preferredRevision;
	this._isPuppeteerCore = isPuppeteerCore;
	}

	/**
	* @param {!(Launcher.LaunchOptions & Launcher.ChromeArgOptions & Launcher.BrowserOptions)=} options
	* @return {!Promise<!Browser>}
	*/
	async launch(options = {}) {
	const {
	ignoreDefaultArgs = false,
	args = [],
	dumpio = false,
	executablePath = null,
	pipe = false,
	env = process.env,
	handleSIGINT = true,
	handleSIGTERM = true,
	handleSIGHUP = true,
	ignoreHTTPSErrors = false,
	defaultViewport = {width: 800, height: 600},
	slowMo = 0,
	timeout = 30000
	} = options;

	const chromeArguments = [];
	if (!ignoreDefaultArgs)
	chromeArguments.push(...this.defaultArgs(options));
	else if (Array.isArray(ignoreDefaultArgs))
	chromeArguments.push(...this.defaultArgs(options).filter(arg => ignoreDefaultArgs.indexOf(arg) === -1));
	else
	chromeArguments.push(...args);

	let temporaryUserDataDir = null;

	if (!chromeArguments.some(argument => argument.startsWith('--remote-debugging-')))
	chromeArguments.push(pipe ? '--remote-debugging-pipe' : '--remote-debugging-port=0');
	if (!chromeArguments.some(arg => arg.startsWith('--user-data-dir'))) {
	temporaryUserDataDir = await mkdtempAsync(CHROME_PROFILE_PATH);
	chromeArguments.push(`--user-data-dir=${temporaryUserDataDir}`);
	}

	let chromeExecutable = executablePath;
	if (!executablePath) {
	const {missingText, executablePath} = this._resolveExecutablePath();
	if (missingText)
	throw new Error(missingText);
	chromeExecutable = executablePath;
	}

	const usePipe = chromeArguments.includes('--remote-debugging-pipe');
	/** @type {!Array<"ignore"\|"pipe">} */
	let stdio = ['pipe', 'pipe', 'pipe'];
	if (usePipe) {
	if (dumpio)
	stdio = ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'];
	else
	stdio = ['ignore', 'ignore', 'ignore', 'pipe', 'pipe'];
	}
	const chromeProcess = childProcess.spawn(
	chromeExecutable,
	chromeArguments,
	{
	// On non-windows platforms, `detached: true` makes child process a leader of a new
	// process group, making it possible to kill child process tree with `.kill(-pid)` command.
	// @see https://nodejs.org/api/child_process.html#child_process_options_detached
	detached: process.platform !== 'win32',
	env,
	stdio
	}
	);

	if (dumpio) {
	chromeProcess.stderr.pipe(process.stderr);
	chromeProcess.stdout.pipe(process.stdout);
	}

	let chromeClosed = false;
	const waitForChromeToClose = new Promise((fulfill, reject) => {
	chromeProcess.once('exit', () => {
	chromeClosed = true;
	// Cleanup as processes exit.
	if (temporaryUserDataDir) {
	removeFolderAsync(temporaryUserDataDir)
	.then(() => fulfill())
	.catch(err => console.error(err));
	} else {
	fulfill();
	}
	});
	});

	const listeners = [ helper.addEventListener(process, 'exit', killChrome) ];
	if (handleSIGINT)
	listeners.push(helper.addEventListener(process, 'SIGINT', () => { killChrome(); process.exit(130); }));
	if (handleSIGTERM)
	listeners.push(helper.addEventListener(process, 'SIGTERM', gracefullyCloseChrome));
	if (handleSIGHUP)
	listeners.push(helper.addEventListener(process, 'SIGHUP', gracefullyCloseChrome));
	/** @type {?Connection} */
	let connection = null;
	try {
	if (!usePipe) {
	const browserWSEndpoint = await waitForWSEndpoint(chromeProcess, timeout, this._preferredRevision);
	const transport = await WebSocketTransport.create(browserWSEndpoint);
	connection = new Connection(browserWSEndpoint, transport, slowMo);
	} else {
	const transport = new PipeTransport(/** @type {!NodeJS.WritableStream} /(chromeProcess.stdio[3]), /* @type {!NodeJS.ReadableStream} */ (chromeProcess.stdio[4]));
	connection = new Connection('', transport, slowMo);
	}
	const browser = await Browser.create(connection, [], ignoreHTTPSErrors, defaultViewport, chromeProcess, gracefullyCloseChrome);
	await browser.waitForTarget(t => t.type() === 'page');
	return browser;
	} catch (e) {
	killChrome();
	throw e;
	}

	/**
	* @return {Promise}
	*/
	function gracefullyCloseChrome() {
	helper.removeEventListeners(listeners);
	if (temporaryUserDataDir) {
	killChrome();
	} else if (connection) {
	// Attempt to close chrome gracefully
	connection.send('Browser.close').catch(error => {
	debugError(error);
	killChrome();
	});
	}
	return waitForChromeToClose;
	}

	// This method has to be sync to be used as 'exit' event handler.
	function killChrome() {
	helper.removeEventListeners(listeners);
	if (chromeProcess.pid && !chromeProcess.killed && !chromeClosed) {
	// Force kill chrome.
	try {
	if (process.platform === 'win32')
	childProcess.execSync(`taskkill /pid ${chromeProcess.pid} /T /F`);
	else
	process.kill(-chromeProcess.pid, 'SIGKILL');
	} catch (e) {
	// the process might have already stopped
	}
	}
	// Attempt to remove temporary profile directory to avoid littering.
	try {
	removeFolder.sync(temporaryUserDataDir);
	} catch (e) { }
	}
	}

	/**
	* @param {!Launcher.ChromeArgOptions=} options
	* @return {!Array<string>}
	*/
	defaultArgs(options = {}) {
	const {
	devtools = false,
	headless = !devtools,
	args = [],
	userDataDir = null
	} = options;
	const chromeArguments = [...DEFAULT_ARGS];
	if (userDataDir)
	chromeArguments.push(`--user-data-dir=${userDataDir}`);
	if (devtools)
	chromeArguments.push('--auto-open-devtools-for-tabs');
	if (headless) {
	chromeArguments.push(
	'--headless',
	'--hide-scrollbars',
	'--mute-audio'
	);
	}
	if (args.every(arg => arg.startsWith('-')))
	chromeArguments.push('about:blank');
	chromeArguments.push(...args);
	return chromeArguments;
	}

	/**
	* @return {string}
	*/
	executablePath() {
	return this._resolveExecutablePath().executablePath;
	}

	/**
	* @param {!(Launcher.BrowserOptions & {browserWSEndpoint?: string, browserURL?: string, transport?: !Puppeteer.ConnectionTransport})} options
	* @return {!Promise<!Browser>}
	*/
	async connect(options) {
	const {
	browserWSEndpoint,
	browserURL,
	ignoreHTTPSErrors = false,
	defaultViewport = {width: 800, height: 600},
	transport,
	slowMo = 0,
	} = options;

	assert(Number(!!browserWSEndpoint) + Number(!!browserURL) + Number(!!transport) === 1, 'Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect');

	let connection = null;
	if (transport) {
	connection = new Connection('', transport, slowMo);
	} else if (browserWSEndpoint) {
	const connectionTransport = await WebSocketTransport.create(browserWSEndpoint);
	connection = new Connection(browserWSEndpoint, connectionTransport, slowMo);
	} else if (browserURL) {
	const connectionURL = await getWSEndpoint(browserURL);
	const connectionTransport = await WebSocketTransport.create(connectionURL);
	connection = new Connection(connectionURL, connectionTransport, slowMo);
	}

	const {browserContextIds} = await connection.send('Target.getBrowserContexts');
	return Browser.create(connection, browserContextIds, ignoreHTTPSErrors, defaultViewport, null, () => connection.send('Browser.close').catch(debugError));
	}

	/**
	* @return {{executablePath: string, missingText: ?string}}
	*/
	_resolveExecutablePath() {
	// puppeteer-core doesn't take into account PUPPETEER_* env variables.
	if (!this._isPuppeteerCore) {
	const executablePath = process.env.PUPPETEER_EXECUTABLE_PATH \|\| process.env.npm_config_puppeteer_executable_path \|\| process.env.npm_package_config_puppeteer_executable_path;
	if (executablePath) {
	const missingText = !fs.existsSync(executablePath) ? 'Tried to use PUPPETEER_EXECUTABLE_PATH env variable to launch browser but did not find any executable at: ' + executablePath : null;
	return { executablePath, missingText };
	}
	}
	const browserFetcher = new BrowserFetcher(this._projectRoot);
	if (!this._isPuppeteerCore) {
	const revision = process.env['PUPPETEER_CHROMIUM_REVISION'];
	if (revision) {
	const revisionInfo = browserFetcher.revisionInfo(revision);
	const missingText = !revisionInfo.local ? 'Tried to use PUPPETEER_CHROMIUM_REVISION env variable to launch browser but did not find executable at: ' + revisionInfo.executablePath : null;
	return {executablePath: revisionInfo.executablePath, missingText};
	}
	}
	const revisionInfo = browserFetcher.revisionInfo(this._preferredRevision);
	const missingText = !revisionInfo.local ? `Chromium revision is not downloaded. Run "npm install" or "yarn install"` : null;
	return {executablePath: revisionInfo.executablePath, missingText};
	}

	}

	/**
	* @param {!Puppeteer.ChildProcess} chromeProcess
	* @param {number} timeout
	* @param {string} preferredRevision
	* @return {!Promise<string>}
	*/
	function waitForWSEndpoint(chromeProcess, timeout, preferredRevision) {
	return new Promise((resolve, reject) => {
	const rl = readline.createInterface({ input: chromeProcess.stderr });
	let stderr = '';
	const listeners = [
	helper.addEventListener(rl, 'line', onLine),
	helper.addEventListener(rl, 'close', () => onClose()),
	helper.addEventListener(chromeProcess, 'exit', () => onClose()),
	helper.addEventListener(chromeProcess, 'error', error => onClose(error))
	];
	const timeoutId = timeout ? setTimeout(onTimeout, timeout) : 0;

	/**
	* @param {!Error=} error
	*/
	function onClose(error) {
	cleanup();
	reject(new Error([
	'Failed to launch chrome!' + (error ? ' ' + error.message : ''),
	stderr,
	'',
	'TROUBLESHOOTING: https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md',
	'',
	].join('\n')));
	}

	function onTimeout() {
	cleanup();
	reject(new TimeoutError(`Timed out after ${timeout} ms while trying to connect to Chrome! The only Chrome revision guaranteed to work is r${preferredRevision}`));
	}

	/**
	* @param {string} line
	*/
	function onLine(line) {
	stderr += line + '\n';
	const match = line.match(/^DevTools listening on (ws:\/\/.*)$/);
	if (!match)
	return;
	cleanup();
	resolve(match[1]);
	}

	function cleanup() {
	if (timeoutId)
	clearTimeout(timeoutId);
	helper.removeEventListeners(listeners);
	}
	});
	}

	/**
	* @param {string} browserURL
	* @return {!Promise<string>}
	*/
	function getWSEndpoint(browserURL) {
	let resolve, reject;
	const promise = new Promise((res, rej) => { resolve = res; reject = rej; });

	const endpointURL = URL.resolve(browserURL, '/json/version');
	const protocol = endpointURL.startsWith('https') ? https : http;
	const requestOptions = Object.assign(URL.parse(endpointURL), { method: 'GET' });
	const request = protocol.request(requestOptions, res => {
	let data = '';
	if (res.statusCode !== 200) {
	// Consume response data to free up memory.
	res.resume();
	reject(new Error('HTTP ' + res.statusCode));
	return;
	}
	res.setEncoding('utf8');
	res.on('data', chunk => data += chunk);
	res.on('end', () => resolve(JSON.parse(data).webSocketDebuggerUrl));
	});

	request.on('error', reject);
	request.end();

	return promise.catch(e => {
	e.message = `Failed to fetch browser webSocket url from ${endpointURL}: ` + e.message;
	throw e;
	});
	}

	/**
	* @typedef {Object} Launcher.ChromeArgOptions
	* @property {boolean=} headless
	* @property {Array<string>=} args
	* @property {string=} userDataDir
	* @property {boolean=} devtools
	*/

	/**
	* @typedef {Object} Launcher.LaunchOptions
	* @property {string=} executablePath
	* @property {boolean\|Array<string>=} ignoreDefaultArgs
	* @property {boolean=} handleSIGINT
	* @property {boolean=} handleSIGTERM
	* @property {boolean=} handleSIGHUP
	* @property {number=} timeout
	* @property {boolean=} dumpio
	* @property {!Object<string, string \| undefined>=} env
	* @property {boolean=} pipe
	*/

	/**
	* @typedef {Object} Launcher.BrowserOptions
	* @property {boolean=} ignoreHTTPSErrors
	* @property {(?Puppeteer.Viewport)=} defaultViewport
	* @property {number=} slowMo
	*/


	module.exports = Launcher;