Issue 5079, 5516 - Use webpack for browser tests, modules for content scripts

chromium_process.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /* eslint-env node */
 /* eslint no-console: "off" */
 
 "use strict";
 
 const childProcess = require("child_process");
 const fs = require("fs");
 const https = require("https");
 const os = require("os");
 const path = require("path");
 
+const extractZip = require("extract-zip");
 const remoteInterface = require("chrome-remote-interface");
-const extractZip = require("extract-zip");
 
 const CHROMIUM_REVISION = 467222;
 
 function rmdir(dirPath)
 {
   for (let file of fs.readdirSync(dirPath))
   {
     let filePath = path.join(dirPath, file);
     try
     {
@@ skipping 200 matching lines @@
     return new Promise((resolve, reject) =>
     {
       setTimeout(() =>
       {
         connectRemoteInterface(attempt + 1).then(resolve).catch(reject);
       }, 200);
     });
   });
 }
 
-function runBootstrap(initialPage, bootstrapPath, bootstrapArgs)
+function runScript(script, scriptName, scriptArgs)
 {
   return connectRemoteInterface().then(async client =>
   {
     try
     {
-      let {Runtime, Log, Console, Page} = client;
+      let {Runtime, Log, Console} = client;
 
       await Log.enable();
       Log.entryAdded(({entry}) =>
       {
         reportMessage(entry.text, entry.level);
       });
 
       await Console.enable();
       Console.messageAdded(({message}) =>
       {
         reportMessage(message.text, message.level);
       });
 
-      await Page.navigate({url: initialPage});
-
       await Runtime.enable();
       let compileResult = await Runtime.compileScript({
-        expression: fs.readFileSync(bootstrapPath, "utf-8"),
-        sourceURL: bootstrapPath,
+        expression: script,
+        sourceURL: scriptName,
         persistScript: true
       });
       if (compileResult.exceptionDetails)
-        throwException(compileResult.exceptionDetails, bootstrapPath);
+        throwException(compileResult.exceptionDetails, scriptName);
 
       let runResult = await Runtime.runScript({
         scriptId: compileResult.scriptId
       });
       if (runResult.exceptionDetails)
-        throwException(runResult.exceptionDetails, bootstrapPath);
+        throwException(runResult.exceptionDetails, scriptName);
 
       let callResult = await Runtime.callFunctionOn({
         objectId: runResult.result.objectId,
-        functionDeclaration: "function(...args) {return this(...args);}",
-        arguments: bootstrapArgs.map(url => ({value: url}))
+        functionDeclaration: "function(...args) { return this(...args); }",
+        arguments: scriptArgs.map(arg => ({value: arg}))
       });
       if (callResult.exceptionDetails)
-        throwException(callResult.exceptionDetails, bootstrapPath);
+        throwException(callResult.exceptionDetails, scriptName);
 
       let promiseResult = await Runtime.awaitPromise({
         promiseObjectId: callResult.result.objectId
       });
       if (promiseResult.exceptionDetails)
-        throwException(promiseResult.exceptionDetails, bootstrapPath);
+        throwException(promiseResult.exceptionDetails, scriptName);
     }
     finally
     {
       client.close();
     }
   });
 }
 
-module.exports = function(initialPage, bootstrapPath, bootstrapArgs)
+module.exports = function(script, scriptName, ...scriptArgs)
 {
   return ensureChromium().then(chromiumPath =>
   {
     let child = startChromium(chromiumPath);
     return Promise.race([
       child.done,
-      runBootstrap(initialPage, bootstrapPath, bootstrapArgs)
+      runScript(script, scriptName, scriptArgs)
     ]).then(result =>
     {
       child.kill();
       return result;
     }).catch(error =>
     {
       child.kill();
       throw error;
     });
   });
 };