Issue 7334 - Remove support for callbacks in API wrappers

polyfill.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present 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/>.
  */
 
 "use strict";
 
 {
-  const asyncAPIs = [
+  let asyncAPIs = [
     "browserAction.setIcon",
-    "browserAction.setBadgeText",
-    "browserAction.setBadgeBackgroundColor",
     "browserAction.getPopup",
     "contextMenus.removeAll",
     "devtools.panels.create",
     "notifications.clear",
     "notifications.create",
     "runtime.getBrowserInfo",
     "runtime.openOptionsPage",
     "runtime.sendMessage",
     "runtime.setUninstallURL",
     "storage.local.get",
     "storage.local.remove",
     "storage.local.set",
     "storage.managed.get",
+    "tabs.captureVisibleTab",
     "tabs.create",
     "tabs.executeScript",
     "tabs.get",
     "tabs.getCurrent",
     "tabs.insertCSS",
     "tabs.query",
     "tabs.reload",
     "tabs.remove",
     "tabs.removeCSS",
     "tabs.sendMessage",
     "tabs.update",
     "webNavigation.getAllFrames",
     "webRequest.handlerBehaviorChanged",
     "windows.create",
     "windows.update"
   ];
 
+  // Microsoft Edge (44.17763.1.0), Chrome (<= 66) and Opera (<= 54)
+  // don't accept passing a callback for
+  // browserAction.setBadgeText and browserAction.setBadgeBackgroundColor
+  const maybeAsyncAPIs = [
+    ["browserAction.setBadgeText", {text: ""}],
+    ["browserAction.setBadgeBackgroundColor", {color: [0, 0, 0, 0]}]
+  ];
+  let syncAPIs = [];
+
   // Since we add a callback for all messaging API calls in our wrappers,
   // Chrome assumes we're interested in the response; when there's no response,
   // it sets runtime.lastError
   const portClosedBeforeResponseError =
     // Older versions of Chrome have a typo:
     // https://crrev.com/c33f51726eacdcc1a487b21a13611f7eab580d6d
     /^The message port closed before a res?ponse was received\.$/;
 
   // This is the error Firefox throws when a message listener is not a
   // function.
   const invalidMessageListenerError = "Invalid listener for runtime.onMessage.";
 
   let messageListeners = new WeakMap();
 
-  function wrapAsyncAPI(api)
+  function getAPIWrappables(api)
   {
     let object = browser;
     let path = api.split(".");
     let name = path.pop();
 
     for (let node of path)
     {
       object = object[node];
 
       if (!object)
         return;
     }
 
     let func = object[name];
     if (!func)
       return;
+
+    return {object, name, func};
+  }
+
+  function wrapAsyncAPI(api)
+  {
+    let wrappables = getAPIWrappables(api);
+
+    if (!wrappables)
+      return;
+
+    let {object, name, func} = wrappables;
 
     // If the property is not writable assigning it will fail, so we use
     // Object.defineProperty here instead. Assuming the property isn't
     // inherited its other attributes (e.g. enumerable) are preserved,
     // except for accessor attributes (e.g. get and set) which are discarded
     // since we're specifying a value.
     Object.defineProperty(object, name, {
       value(...args)
       {
-        let lastArgumentType = typeof args[args.length - 1];
-
-        // If the last argument is undefined, we assume it stands for the
-        // optional callback.
-        if (lastArgumentType == "function" || lastArgumentType == "undefined")
-          throw new Error("Callbacks are no longer supported.");
-
         let resolvePromise = null;
         let rejectPromise = null;
 
         func.call(object, ...args, result =>
         {
           let error = browser.runtime.lastError;
           if (error && !portClosedBeforeResponseError.test(error.message))
           {
             // runtime.lastError is already an Error instance on Edge, while on
             // Chrome it is a plain object with only a message property.
             if (!(error instanceof Error))
               error = new Error(error.message);
 
             rejectPromise(error);
           }
           else
           {
             resolvePromise(result);
           }
         });
 
         return new Promise((resolve, reject) =>
         {
           resolvePromise = resolve;
           rejectPromise = reject;
         });
+      }
+    });
+  }
+
+  function wrapSyncAPI(api)
+  {
+    let wrappables = getAPIWrappables(api);
+
+    if (!wrappables)
+      return;
+
+    let {object, name, func} = wrappables;
+
+    Object.defineProperty(object, name, {
+      value(...args)
+      {
+        return Promise.resolve(func.call(object, ...args));
       }
     });
   }
 
   function wrapRuntimeOnMessage()
   {
     let {onMessage} = browser.runtime;
     let {addListener, removeListener} = onMessage;
 
     onMessage.addListener = function(listener)
@@ skipping 62 matching lines @@
     {
       return !(browser.storage.local.get([]) instanceof Promise);
     }
     catch (error)
     {
     }
 
     return true;
   }
 
+  function acceptsCallback(func, args)
+  {
+    try
+    {
+      func(...args, () => {});
+      return true;
+    }
+    catch (e)
+    {
+      return false;
+    }
+  }
+
   if (shouldWrapAPIs())
   {
     // Unlike Firefox and Microsoft Edge, Chrome doesn't have a "browser"
     // object, but provides the extension API through the "chrome" namespace
     // (non-standard).
     if (typeof browser == "undefined")
-      window.browser = chrome;
+      self.browser = chrome;
+
+    for (let [api, ...testArgs] of maybeAsyncAPIs)
+    {
+      let wrappables = getAPIWrappables(api);
+
+      if (!wrappables)
+        continue;
+
+      let {func} = wrappables;
+
+      (acceptsCallback(func, testArgs) ? asyncAPIs : syncAPIs).push(api);
+    }
 
     for (let api of asyncAPIs)
       wrapAsyncAPI(api);
+
+    for (let api of syncAPIs)
+      wrapSyncAPI(api);
 
     wrapRuntimeOnMessage();
   }
 
   // Workaround since HTMLCollection, NodeList, StyleSheetList, and CSSRuleList
   // didn't have iterator support before Chrome 51.
   // https://bugs.chromium.org/p/chromium/issues/detail?id=401699
   for (let object of [HTMLCollection, NodeList, StyleSheetList, CSSRuleList])
   {
     if (!(Symbol.iterator in object.prototype))
       object.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
   }
 }
+
+// Object.values is not supported in Chrome <54.
+if (!("values" in Object))
+  Object.values = obj => Object.keys(obj).map(key => obj[key]);
+
+// Microsoft Edge (42.17134.1.0) doesn't support webRequest.ResourceType, but
+// we can obtain the list of accepted resource types from the error message
+// when creating an onBeforeRequest event listener with an unsupported resource
+// type.
+if ("webRequest" in browser && !("ResourceType" in browser.webRequest))
+{
+  try
+  {
+    browser.webRequest.onBeforeRequest.addListener(
+      details => {}, {urls: ["<all_urls>"], types: ["foo"]}
+    );
+  }
+  catch (error)
+  {
+    let errorMessage = error.toString();
+    errorMessage = errorMessage.substr(errorMessage.lastIndexOf(":"));
+
+    browser.webRequest.ResourceType = {};
+    if (errorMessage.includes("main_frame"))
+    {
+      for (let type of errorMessage.match(/[a-z_]+/g))
+        browser.webRequest.ResourceType[type.toUpperCase()] = type;
+    }
+  }
+}
+
+// Chrome <50 does not support createImageBitmap, this is a simplistic
+// polyfill which only fulfills the usecase of accepting a Blob containing
+// an image and returning something which CanvasRenderingContext2D.drawImage()
+// accepts.
+if (typeof createImageBitmap == "undefined")
+{
+  self.createImageBitmap = blob =>
+  {
+    return new Promise((resolve, reject) =>
+    {
+      let image = new Image();
+      image.src = URL.createObjectURL(blob);
+      image.addEventListener("load", () =>
+      {
+        URL.revokeObjectURL(image.src);
+        resolve(image);
+      });
+      image.addEventListener("error", () =>
+      {
+        URL.revokeObjectURL(image.src);
+        reject("createImageBitmap failed");
+      });
+    });
+  };
+}
+
+// Chrome <69 does not support OffscreenCanvas
+if (typeof OffscreenCanvas == "undefined")
+{
+  self.OffscreenCanvas = function(width, height)
+  {
+    let canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  };
+}