opal 1.6.1 → 1.7.0

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/devtools.js

@@ -3,243 +3,123 @@
 const http = require('http');
 const https = require('https');
 
-const defaults = require('./defaults');
-const externalRequest = require('./external-request');
+const defaults = require('./defaults.js');
+const externalRequest = require('./external-request.js');
 
-// callback(err, protocol)
-module.exports.Protocol = promisesWrapper(function (options, callback) {
+// options.path must be specified; callback(err, data)
+function devToolsInterface(path, options, callback) {
+    const transport = options.secure ? https : http;
+    const requestOptions = {
+        host: options.host || defaults.HOST,
+        port: options.port || defaults.PORT,
+        useHostName: options.useHostName,
+        path: (options.alterPath ? options.alterPath(path) : path)
+    };
+    externalRequest(transport, requestOptions, callback);
+}
+
+// wrapper that allows to return a promise if the callback is omitted, it works
+// for DevTools methods
+function promisesWrapper(func) {
+    return (options, callback) => {
+        // options is an optional argument
+        if (typeof options === 'function') {
+            callback = options;
+            options = undefined;
+        }
+        options = options || {};
+        // just call the function otherwise wrap a promise around its execution
+        if (typeof callback === 'function') {
+            func(options, callback);
+            return undefined;
+        } else {
+            return new Promise((fulfill, reject) => {
+                func(options, (err, result) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        fulfill(result);
+                    }
+                });
+            });
+        }
+    };
+}
+
+function Protocol(options, callback) {
     // if the local protocol is requested
-    if (!options.remote) {
+    if (options.local) {
         const localDescriptor = require('./protocol.json');
-        callback(null, {
-            'remote': false,
-            'descriptor': localDescriptor
-        });
+        callback(null, localDescriptor);
         return;
     }
-    // try to fecth the browser version information and the protocol (remotely)
-    module.exports.Version(options, function (err, info) {
+    // try to fetch the protocol remotely
+    devToolsInterface('/json/protocol', options, (err, descriptor) => {
         if (err) {
             callback(err);
-            return;
-        }
-        // fetch the reported browser info (Node.js returns an array)
-        const browser = (info[0] || info).Browser;
-        // use the proper protocol fetcher
-        let fetcher;
-        if (browser.match(/^(Headless)?Chrome\//)) {
-            // https://bugs.chromium.org/p/chromium/issues/detail?id=538300#c10
-            const firstJsonProtocolVersion = '60.0.3097.0';
-            const firstJsonProtocolBuild = explodeChromeVersion(firstJsonProtocolVersion)[2];
-            const chromeBuild = explodeChromeVersion(info.Browser.split('/')[1])[2];
-            if (chromeBuild < firstJsonProtocolBuild) {
-                fetcher = fetchFromChromeRepo;
-            } else {
-                fetcher = fetchFromHttpEndpoint;
-            }
-        } else if (browser.match(/^Microsoft Edge /)) {
-            fetcher = fetchFromHttpEndpoint;
-        } else if (browser.match(/^node.js\//)) {
-            fetcher = fetchFromHttpEndpoint;
         } else {
-            callback(new Error('Unknown implementation'));
-            return;
+            callback(null, JSON.parse(descriptor));
         }
-        fetcher(options, info, function (err, descriptor) {
-            if (err) {
-                callback(err);
-                return;
-            }
-            // use the remotely fetched descriptor
-            callback(null, {
-                'remote': true,
-                'descriptor': descriptor
-            });
-        });
     });
-});
+}
 
-module.exports.List = promisesWrapper(function (options, callback) {
-    options.path = '/json/list';
-    devToolsInterface(options, function (err, tabs) {
+function List(options, callback) {
+    devToolsInterface('/json/list', options, (err, tabs) => {
         if (err) {
             callback(err);
         } else {
             callback(null, JSON.parse(tabs));
         }
     });
-});
+}
 
-module.exports.New = promisesWrapper(function (options, callback) {
-    options.path = '/json/new';
+function New(options, callback) {
+    let path = '/json/new';
     if (Object.prototype.hasOwnProperty.call(options, 'url')) {
-        options.path += '?' + options.url;
+        path += `?${options.url}`;
     }
-    devToolsInterface(options, function (err, tab) {
+    devToolsInterface(path, options, (err, tab) => {
         if (err) {
             callback(err);
         } else {
             callback(null, JSON.parse(tab));
         }
     });
-});
+}
 
-module.exports.Activate = promisesWrapper(function (options, callback) {
-    options.path = '/json/activate/' + options.id;
-    devToolsInterface(options, function (err) {
+function Activate(options, callback) {
+    devToolsInterface('/json/activate/' + options.id, options, (err) => {
         if (err) {
             callback(err);
         } else {
             callback(null);
         }
     });
-});
+}
 
-module.exports.Close = promisesWrapper(function (options, callback) {
-    options.path = '/json/close/' + options.id;
-    devToolsInterface(options, function (err) {
+function Close(options, callback) {
+    devToolsInterface('/json/close/' + options.id, options, (err) => {
         if (err) {
             callback(err);
         } else {
             callback(null);
         }
     });
-});
+}
 
-module.exports.Version = promisesWrapper(function (options, callback) {
-    options.path = '/json/version';
-    devToolsInterface(options, function (err, versionInfo) {
+function Version(options, callback) {
+    devToolsInterface('/json/version', options, (err, versionInfo) => {
         if (err) {
             callback(err);
         } else {
             callback(null, JSON.parse(versionInfo));
         }
     });
-});
-
-// options.path must be specified; callback(err, data)
-function devToolsInterface(options, callback) {
-    options.host = options.host || defaults.HOST;
-    options.port = options.port || defaults.PORT;
-    options.secure = !!(options.secure);
-    externalRequest(options.secure ? https : http, options, callback);
 }
 
-// wrapper that allows to return a promise if the callback is omitted, it works
-// for DevTools methods
-function promisesWrapper(func) {
-    return function (options, callback) {
-        // options is an optional argument
-        if (typeof options === 'function') {
-            callback = options;
-            options = undefined;
-        }
-        options = options || {};
-        // just call the function otherwise wrap a promise around its execution
-        if (typeof callback === 'function') {
-            func(options, callback);
-        } else {
-            return new Promise(function (fulfill, reject) {
-                func(options, function (err, result) {
-                    if (err) {
-                        reject(err);
-                    } else {
-                        fulfill(result);
-                    }
-                });
-            });
-        }
-    };
-}
-
-function explodeChromeVersion(v) {
-    return v.split('.').map(function (x) {
-        return parseInt(x);
-    });
-}
-
-// callback(err, descriptor)
-// XXX this function needs a proper refactor but the inconsistency of the
-// fetching process makes it useless for now
-function fetchFromChromeRepo(options, info, callback) {
-    // attempt to fetch the protocol directly from the Chromium repository
-    // according to the current version
-    //
-    // Thanks to Paul Irish.
-    // (see https://github.com/cyrus-and/chrome-remote-interface/issues/10#issuecomment-146032907)
-    const webKitVersion = info['WebKit-Version'];
-    const v8Version = info['V8-Version'];
-    const match = webKitVersion.match(/\s\(@(\b[0-9a-f]{5,40}\b)/);
-    const hash = match[1];
-    const fromChromiumDotOrg = (hash <= 202666);
-    let urls;
-    if (fromChromiumDotOrg) {
-        urls = [`https://src.chromium.org/blink/trunk/Source/devtools/protocol.json?p=${hash}`];
-    } else {
-        const lastBeforeSplitChromeVersion = '53.0.2758.1'; // before the split (https://crbug.com/580337)
-        const lastBeforeV8ChromeVersion = '55.0.2854.3'; // before using the JSON from the V8 repo
-        const chromeVersion = explodeChromeVersion(info.Browser.split('/')[1]);
-        // according to https://www.chromium.org/developers/version-numbers (patch not meaningful)
-        const beforeSplit = (chromeVersion[2] <= explodeChromeVersion(lastBeforeSplitChromeVersion)[2]);
-        const beforeFromV8 = (chromeVersion[2] <= explodeChromeVersion(lastBeforeV8ChromeVersion)[2]);
-        if (beforeSplit) {
-            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/devtools/protocol.json?format=TEXT`];
-        } else if (beforeFromV8) {
-            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/core/inspector/browser_protocol.json?format=TEXT`,
-                    `https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/platform/v8_inspector/js_protocol.json?format=TEXT`];
-        } else if (v8Version) {
-            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/core/inspector/browser_protocol.json?format=TEXT`,
-                    `https://chromium.googlesource.com/v8/v8/+/${v8Version}/src/inspector/js_protocol.json?format=TEXT`];
-        } else {
-            console.error('Warning: the protocol might be outdated, see: https://groups.google.com/d/topic/chrome-debugging-protocol/HjyOKainKus/discussion');
-            // releases which do not provide a V8 version get an old version of the V8 protocol
-            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/core/inspector/browser_protocol.json?format=TEXT`,
-                    `https://chromium.googlesource.com/chromium/src/+/${lastBeforeV8ChromeVersion}/third_party/WebKit/Source/platform/v8_inspector/js_protocol.json?format=TEXT`];
-        }
-    }
-    const descriptors = [];
-    urls.forEach(function (url) {
-        externalRequest(https, url, function (err, data) {
-            let descriptor;
-            if (!err) {
-                try {
-                    // the file is served base64 encoded from googlesource.com
-                    if (!fromChromiumDotOrg) {
-                        data = new Buffer(data, 'base64').toString();
-                    }
-                    descriptor = JSON.parse(data);
-                } catch (_) {
-                    // abort later
-                }
-            }
-            descriptors.push(descriptor);
-            if (descriptors.length === urls.length) {
-                // all must be defined
-                if (descriptors.indexOf(undefined) !== -1) {
-                    callback(new Error('Cannot fetch from Chromium repo'));
-                    return;
-                }
-                // merge the domains
-                descriptors.forEach(function (descriptor, i) {
-                    if (i === 0) {
-                        return;
-                    }
-                    Array.prototype.push.apply(descriptors[0].domains, descriptor.domains);
-                });
-                callback(null, descriptors[0]);
-            }
-        });
-    });
-}
-
-// callback(err, descriptor)
-function fetchFromHttpEndpoint(options, info, callback) {
-    options.path = '/json/protocol';
-    devToolsInterface(options, function (err, descriptor) {
-        if (err) {
-            callback(err);
-        } else {
-            callback(null, JSON.parse(descriptor));
-        }
-    });
-}
+module.exports.Protocol = promisesWrapper(Protocol);
+module.exports.List = promisesWrapper(List);
+module.exports.New = promisesWrapper(New);
+module.exports.Activate = promisesWrapper(Activate);
+module.exports.Close = promisesWrapper(Close);
+module.exports.Version = promisesWrapper(Version);

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/external-request.js

@@ -1,13 +1,32 @@
 'use strict';
 
+const dns = require('dns');
+const util = require('util');
+
+const REQUEST_TIMEOUT = 10000;
+
 // callback(err, data)
-function externalRequest(transport, options, callback) {
-    const request = transport.get(options, function (response) {
+async function externalRequest(transport, options, callback) {
+    // perform the DNS lookup manually so that the HTTP host header generated by
+    // http.get will contain the IP address, this is needed because since Chrome
+    // 66 the host header cannot contain an host name different than localhost
+    // (see https://github.com/cyrus-and/chrome-remote-interface/issues/340)
+    if (!options.useHostName) {
+        try {
+            const {address} = await util.promisify(dns.lookup)(options.host);
+            options.host = address;
+        } catch (err) {
+            callback(err);
+            return;
+        }
+    }
+    // perform the actual request
+    const request = transport.get(options, (response) => {
         let data = '';
-        response.on('data', function (chunk) {
+        response.on('data', (chunk) => {
             data += chunk;
         });
-        response.on('end', function () {
+        response.on('end', () => {
             if (response.statusCode === 200) {
                 callback(null, data);
             } else {
@@ -15,9 +34,10 @@ function externalRequest(transport, options, callback) {
             }
         });
     });
-    request.on('error', function (err) {
-        callback(err);
+    request.setTimeout(REQUEST_TIMEOUT, () => {
+        request.abort();
     });
+    request.on('error', callback);
 }
 
 module.exports = externalRequest;