[fix]: Removed synchronous operation with file system.

lib/Launcher.js

@@ -15,16 +15,18 @@
  */
 const os = require('os');
 const path = require('path');
-const removeSync = require('rimraf').sync;
+const {helper} = require('./helper');
+const rimrafAsync = helper.promisify(require('rimraf'));
 const childProcess = require('child_process');
 const Downloader = require('../utils/ChromiumDownloader');
 const Connection = require('./Connection');
 const Browser = require('./Browser');
 const readline = require('readline');
 const fs = require('fs');
-const {helper} = require('./helper');
 const ChromiumRevision = require('../package.json').puppeteer.chromium_revision;
 
+fs.mkdtempAsync = helper.promisify(fs.mkdtemp);
+
 const CHROME_PROFILE_PATH = path.join(os.tmpdir(), 'puppeteer_dev_profile-');
 
 const DEFAULT_ARGS = [
@@ -59,7 +61,7 @@ class Launcher {
     const chromeArguments = [].concat(DEFAULT_ARGS);
     if (!options.args || !options.args.some(arg => arg.startsWith('--user-data-dir'))) {
       if (!options.userDataDir)
-        temporaryUserDataDir = fs.mkdtempSync(CHROME_PROFILE_PATH);
+        temporaryUserDataDir = await fs.mkdtempAsync(CHROME_PROFILE_PATH);
 
       chromeArguments.push(`--user-data-dir=${options.userDataDir || temporaryUserDataDir}`);
     }
@@ -90,8 +92,11 @@ class Launcher {
       chromeProcess.once('close', () => {
         // Cleanup as processes exit.
         if (temporaryUserDataDir)
-          removeSync(temporaryUserDataDir);
-        fulfill();
+          rimrafAsync(temporaryUserDataDir)
+            .then(() => fulfill())
+            .catch(err => console.error(err));
+        else
+          fulfill();
       });
     });
 
@@ -112,7 +117,7 @@ class Launcher {
     /**
      * @return {Promise}
      */
-    function killChrome() {
+    async function killChrome() {
       helper.removeEventListeners(listeners);
       if (temporaryUserDataDir) {
         // Force kill chrome.
@@ -122,7 +127,7 @@ class Launcher {
           process.kill(-chromeProcess.pid, 'SIGKILL');
         // Attempt to remove temporary profile directory to avoid littering.
         try {
-          removeSync(temporaryUserDataDir);
+          await rimrafAsync(temporaryUserDataDir);
         } catch (e) { }
       } else {
         // Terminate chrome gracefully.

lib/Page.js

@@ -26,6 +26,8 @@ const {Keyboard, Mouse, Touchscreen} = require('./Input');
 const Tracing = require('./Tracing');
 const {helper, debugError} = require('./helper');
 
+const writeFileAsync = helper.promisify(fs.writeFile);
+
 class Page extends EventEmitter {
   /**
    * @param {!Session} client
@@ -585,7 +587,7 @@ class Page extends EventEmitter {
 
     const buffer = new Buffer(result.data, 'base64');
     if (options.path)
-      fs.writeFileSync(options.path, buffer);
+      await writeFileAsync(options.path, buffer);
     return buffer;
   }
 
@@ -633,7 +635,7 @@ class Page extends EventEmitter {
     });
     const buffer = new Buffer(result.data, 'base64');
     if (options.path)
-      fs.writeFileSync(options.path, buffer);
+      await writeFileAsync(options.path, buffer);
     return buffer;
   }
 

lib/Tracing.js

@@ -13,8 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const fs = require('fs');
 const {helper} = require('./helper');
+const fs = require('fs');
+
+fs.openAsync = helper.promisify(fs.open);
+fs.writeAsync = helper.promisify(fs.write);
+fs.closeAsync = helper.promisify(fs.close);
 
 class Tracing {
   /**
@@ -68,14 +72,14 @@ class Tracing {
    */
   async _readStream(handle, path) {
     let eof = false;
-    const file = fs.openSync(path, 'w');
+    const file = await fs.openAsync(path, 'w');
     while (!eof) {
       const response = await this._client.send('IO.read', {handle});
       eof = response.eof;
       if (path)
-        fs.writeSync(file, response.data);
+        await fs.writeAsync(file, response.data);
     }
-    fs.closeSync(file);
+    await fs.closeAsync(file);
     await this._client.send('IO.close', {handle});
   }
 }

lib/helper.js

@@ -15,6 +15,7 @@
  */
 
 const debugError = require('debug')(`puppeteer:error`);
+const util = require('util');
 /** @type {?Map<string, boolean>} */
 let apiCoverage = null;
 class Helper {
@@ -225,6 +226,86 @@ class Helper {
   static isNumber(obj) {
     return typeof obj === 'number' || obj instanceof Number;
   }
+
+  /**
+   * @static
+   * @param {function(?)} nodeFunction
+   * @throws {TypeError} - Throws error if argument isn't a function.
+   * @return {function(?):!Promise<?>}
+   * @example
+   *   const writeFileAsync = Helper.promisify(require('fs').writeFile);
+   *   ...
+   *     await writeFileAsync(...);
+   */
+  static promisify(nodeFunction) {
+    if (typeof nodeFunction !== 'function')
+      throw new TypeError('A function is expected');
+
+
+    // If code run under NodeJS v8+, then by util.promisify.custom key
+    // may exist promisified version of function.
+    // see: https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_custom_promisified_functions
+    if (util.promisify && util.promisify.custom) {
+      if (nodeFunction[util.promisify.custom])
+        /**
+         * @param {!Array<?>} args
+         * @return {!Promise<?>}
+         */
+        return util.promisify(nodeFunction);
+    }
+
+    // Because native util.promisify differently work with arguments
+    // we can't use this function as ponyfill
+
+    /**
+     * @param {!Array<?>} args
+     * @return {!Promise<?>}
+     */
+    function promisified(...args) {
+      return new Promise((resolve, reject) => {
+        function callback(err, ...result) {
+          if (err)
+            return reject(err);
+
+          // If callback invoked with single argument, we return in in Promise directly
+          if (result.length === 1)
+            return resolve(result[0]);
+          else
+            // Otherwise return array of arguments
+            return resolve(result);
+        }
+        args.push(callback);
+        nodeFunction.call(null, ...args);
+      });
+    }
+
+    promisified.__isPromisified__ = true;
+    return promisified;
+  }
+
+  /**
+   * @description Add to object for each method promisified analog by ${methodName}Async
+   * @static
+   * @param {Object} object
+   * @example
+   *  const fs = Helper.promisifyAll(require('fs'));
+   *  fs.writeFileAsync(...); // -> Promise
+   */
+  static promisifyAll(object) {
+    // Yes, this method make promise wrapper for all methods in object,
+    // and for synchronous too.
+    // But because we don't rewrite method, just don't try use ${methodName}Async
+    // for initially synchronous methods.
+
+    Object.keys(object).forEach(key => {
+      if (typeof object[key] !== 'function')
+        return;
+
+      object[`${key}Async`] = Helper.promisify(object[key]);
+    });
+
+    return object;
+  }
 }
 
 module.exports = {