async'ify msg, don't throw for flow control

background/background.js

@@ -258,7 +258,7 @@ if (FIREFOX && browser.commands && browser.commands.update) {
   });
 }
 
-msg.broadcastTab({method: 'backgroundReady'});
+msg.broadcast({method: 'backgroundReady'});
 
 function webNavIframeHelperFF({tabId, frameId}) {
   if (!frameId) return;

content/apply.js

@@ -150,13 +150,10 @@ self.INJECTED !== 1 && (() => {
         break;
 
       case 'backgroundReady':
-        initializing
+        initializing.catch(err =>
-          .catch(err => {
+          msg.isIgnorableError(err)
-            if (msg.RX_NO_RECEIVER.test(err.message)) {
+            ? init()
-              return init();
+            : console.error(err));
-            }
-          })
-          .catch(console.error);
         break;
 
       case 'updateCount':

js/msg.js

@@ -1,258 +1,169 @@
-/* global promisifyChrome deepCopy */
+/* global promisifyChrome deepCopy getOwnTab URLS msg */
-// deepCopy is only used if the script is executed in extension pages.
 'use strict';
 
-self.msg = self.INJECTED === 1 ? self.msg : (() => {
+// eslint-disable-next-line no-unused-expressions
+window.INJECTED !== 1 && (() => {
   promisifyChrome({
     runtime: ['sendMessage'],
     tabs: ['sendMessage', 'query'],
   });
-  const isBg = chrome.extension.getBackgroundPage && chrome.extension.getBackgroundPage() === window;
+  const TARGETS = Object.assign(Object.create(null), {
-  if (isBg) {
+    all: ['both', 'tab', 'extension'],
-    window._msg = {
+    extension: ['both', 'extension'],
-      handler: null,
+    tab: ['both', 'tab'],
-      clone: deepCopy
-    };
-  }
-  const bgReady = getBg();
-  const EXTENSION_URL = chrome.runtime.getURL('');
-  let handler;
-  const RX_NO_RECEIVER = /Receiving end does not exist/;
-  // typo in Chrome 49
-  const RX_PORT_CLOSED = /The message port closed before a res?ponse was received/;
-  return {
-    send,
-    sendTab,
-    sendBg,
-    broadcast,
-    broadcastTab,
-    broadcastExtension,
-    ignoreError,
-    on,
-    onTab,
-    onExtension,
-    off,
-    RX_NO_RECEIVER,
-    RX_PORT_CLOSED,
-    isBg,
-  };
-
-  function getBg() {
-    if (isBg) {
-      return Promise.resolve(window);
-    }
-    // try using extension.getBackgroundPage because runtime.getBackgroundPage is too slow
-    // https://github.com/openstyles/stylus/issues/771
-    if (chrome.extension.getBackgroundPage) {
-      const bg = chrome.extension.getBackgroundPage();
-      if (bg && bg.document && bg.document.readyState !== 'loading') {
-        return Promise.resolve(bg);
-      }
-    }
-    if (chrome.runtime.getBackgroundPage) {
-      promisifyChrome({
-        runtime: ['getBackgroundPage'],
   });
-      return browser.runtime.getBackgroundPage().catch(() => null);
+  const NEEDS_TAB_IN_SENDER = [
-    }
+    'getTabUrlPrefix',
-    return Promise.resolve(null);
+    'updateIconBadge',
-  }
+    'styleViaAPI',
+  ];
+  const isBg = getExtBg() === window;
+  const handler = {
+    both: new Set(),
+    tab: new Set(),
+    extension: new Set(),
+  };
 
-  function send(data, target = 'extension') {
+  chrome.runtime.onMessage.addListener(handleMessage);
-    const message = {data, target};
-    return browser.runtime.sendMessage(message).then(unwrapData);
-  }
 
-  function sendTab(tabId, data, options, target = 'tab') {
+  window.API = new Proxy({}, {
-    return browser.tabs.sendMessage(tabId, {data, target}, options)
+    get(target, name) {
-      .then(unwrapData);
+      return async (...args) => {
-  }
+        const bg = isBg && window || chrome.tabs && (getExtBgIfReady() || await getRuntimeBg());
-
+        const message = {method: 'invokeAPI', name, args};
-  function sendBg(data) {
+        // frames and probably private tabs
-    return bgReady.then(bg => {
+        if (!bg || window !== parent) return msg.send(message);
-      if (bg) {
-        if (!bg._msg.handler) {
-          throw new Error('there is no bg handler');
-        }
-        const handlers = bg._msg.handler.extension.concat(bg._msg.handler.both);
         // in FF, the object would become a dead object when the window
         // is closed, so we have to clone the object into background.
-        return Promise.resolve(executeCallbacks(handlers, bg._msg.clone(data), {url: location.href}))
+        const res = bg.msg._execute(TARGETS.extension, bg.deepCopy(message), {
-          .then(deepCopy);
+          frameId: 0,
-      }
+          tab: NEEDS_TAB_IN_SENDER.includes(name) && await getOwnTab(),
-      return send(data);
+          url: location.href,
+        });
+        // avoiding an unnecessary `await` microtask сycle
+        return deepCopy(res instanceof bg.Promise ? await res : res);
+      };
+    },
   });
-  }
 
-  function ignoreError(err) {
+  window.msg = {
-    if (err.message && (
+    isBg,
-      RX_NO_RECEIVER.test(err.message) ||
-      RX_PORT_CLOSED.test(err.message)
-    )) {
-      return;
-    }
-    console.warn(err);
-  }
 
-  function broadcast(data, filter) {
+    async broadcast(data) {
-    return Promise.all([
+      const requests = [msg.send(data, 'both').catch(msg.ignoreError)];
-      send(data, 'both').catch(ignoreError),
+      for (const tab of await browser.tabs.query({})) {
-      broadcastTab(data, filter, null, true, 'both')
+        const url = tab.pendingUrl || tab.url;
-    ]);
+        if (!tab.discarded &&
-  }
+            !url.startsWith(URLS.ownOrigin) &&
-
+            URLS.supported(url)) {
-  function broadcastTab(data, filter, options, ignoreExtension = false, target = 'tab') {
+          requests[tab.active ? 'unshift' : 'push'](
-    return browser.tabs.query({})
+            msg.sendTab(tab.id, data, null, 'both').catch(msg.ignoreError));
-      // TODO: send to activated tabs first?
-      .then(tabs => {
-        const requests = [];
-        for (const tab of tabs) {
-          const tabUrl = tab.pendingUrl || tab.url;
-          const isExtension = tabUrl.startsWith(EXTENSION_URL);
-          if (
-            tab.discarded ||
-            // FIXME: use `URLS.supported`?
-            !/^(http|ftp|file)/.test(tabUrl) &&
-            !tabUrl.startsWith('chrome://newtab/') &&
-            !isExtension ||
-            isExtension && ignoreExtension ||
-            filter && !filter(tab)
-          ) {
-            continue;
-          }
-          const dataObj = typeof data === 'function' ? data(tab) : data;
-          if (!dataObj) {
-            continue;
-          }
-          const message = {data: dataObj, target};
-          if (tab && tab.id) {
-            requests.push(
-              browser.tabs.sendMessage(tab.id, message, options)
-                .then(unwrapData)
-                .catch(ignoreError)
-            );
         }
       }
       return Promise.all(requests);
-      });
+    },
-  }
 
-  function broadcastExtension(...args) {
+    isIgnorableError(err) {
-    return send(...args).catch(ignoreError);
+      return /Receiving end does not exist|The message port closed before/.test(err.message);
-  }
+    },
 
-  function on(fn) {
+    ignoreError(err) {
-    initHandler();
+      if (!msg.isIgnorableError(err)) {
-    handler.both.push(fn);
+        console.warn(err);
       }
+    },
 
-  function onTab(fn) {
+    on(fn) {
-    initHandler();
+      handler.both.add(fn);
-    handler.tab.push(fn);
+    },
-  }
 
-  function onExtension(fn) {
+    onTab(fn) {
-    initHandler();
+      handler.tab.add(fn);
-    handler.extension.push(fn);
+    },
-  }
 
-  function off(fn) {
+    onExtension(fn) {
-    for (const type of ['both', 'tab', 'extension']) {
+      handler.extension.add(fn);
-      const index = handler[type].indexOf(fn);
+    },
-      if (index >= 0) {
-        handler[type].splice(index, 1);
-      }
-    }
-  }
 
-  function initHandler() {
+    off(fn) {
-    if (handler) {
+      for (const type of TARGETS.all) {
-      return;
+        handler[type].delete(fn);
-    }
-    handler = {
-      both: [],
-      tab: [],
-      extension: []
-    };
-    if (isBg) {
-      window._msg.handler = handler;
-    }
-    chrome.runtime.onMessage.addListener(handleMessage);
       }
+    },
 
-  function executeCallbacks(callbacks, ...args) {
+    send(data, target = 'extension') {
+      return browser.runtime.sendMessage({data, target})
+        .then(unwrapData);
+    },
+
+    sendTab(tabId, data, options, target = 'tab') {
+      return browser.tabs.sendMessage(tabId, {data, target}, options)
+        .then(unwrapData);
+    },
+
+    _execute(types, ...args) {
       let result;
-    for (const fn of callbacks) {
+      for (const type of types) {
-      const data = withPromiseError(fn, ...args);
+        for (const fn of handler[type]) {
-      if (data !== undefined && result === undefined) {
+          let res;
-        result = data;
+          try {
+            res = fn(...args);
+          } catch (err) {
+            res = Promise.reject(err);
+          }
+          if (res !== undefined && result === undefined) {
+            result = res;
+          }
         }
       }
       return result;
+    },
+  };
+
+  function getExtBg() {
+    const fn = chrome.extension.getBackgroundPage;
+    return fn && fn();
   }
 
-  function handleMessage(message, sender, sendResponse) {
+  function getExtBgIfReady() {
-    const handlers = message.target === 'tab' ?
+    const bg = getExtBg();
-      handler.tab.concat(handler.both) : message.target === 'extension' ?
+    return bg && bg.document && bg.document.readyState !== 'loading' && bg;
-      handler.extension.concat(handler.both) :
-      handler.both.concat(handler.extension, handler.tab);
-    if (!handlers.length) {
-      return;
   }
-    const result = executeCallbacks(handlers, message.data, sender);
+
-    if (result === undefined) {
+  function getRuntimeBg() {
-      return;
+    return new Promise(resolve =>
+      chrome.runtime.getBackgroundPage(bg =>
+        resolve(!chrome.runtime.lastError && bg)));
   }
-    Promise.resolve(result)
+
-      .then(
+  function handleMessage({data, target}, sender, sendResponse) {
-        data => ({
+    const res = msg._execute(TARGETS[target] || TARGETS.all, data, sender);
-          error: false,
+    if (res instanceof Promise) {
-          data
+      handleResponseAsync(res, sendResponse);
-        }),
+      return true;
-        err => ({
+    }
+    if (res !== undefined) sendResponse({data: res});
+  }
+
+  async function handleResponseAsync(promise, sendResponse) {
+    try {
+      sendResponse({
+        data: await promise,
+      });
+    } catch (err) {
+      sendResponse({
         error: true,
         data: Object.assign({
           message: err.message || String(err),
-            // FIXME: do we want to pass the entire stack?
+          stack: err.stack,
-            stack: err.stack
+        }, err), // passing custom properties e.g. `err.index` to unwrapData
-          }, err) // this allows us to pass custom properties e.g. `err.index`
+      });
-        })
-      )
-      .then(sendResponse);
-    return true;
-  }
-
-  function withPromiseError(fn, ...args) {
-    try {
-      return fn(...args);
-    } catch (err) {
-      return Promise.reject(err);
     }
   }
 
-  // {type, error, data, id}
+  function unwrapData({data, error} = {}) {
-  function unwrapData(result) {
+    return error
-    if (result === undefined) {
+      ? Promise.reject(Object.assign(new Error(data.message), data))
-      throw new Error('Receiving end does not exist');
+      : data;
-    }
-    if (result.error) {
-      throw Object.assign(new Error(result.data.message), result.data);
-    }
-    return result.data;
   }
 })();
-
-self.API = self.INJECTED === 1 ? self.API : new Proxy({
-  // Handlers for these methods need sender.tab.id which is set by `send` as it uses messaging,
-  // unlike `sendBg` which invokes the background page directly in our own extension tabs
-  getTabUrlPrefix: true,
-  updateIconBadge: true,
-  styleViaAPI: true,
-}, {
-  get: (target, name) =>
-    (...args) => Promise.resolve(self.msg[target[name] ? 'send' : 'sendBg']({
-      method: 'invokeAPI',
-      name,
-      args
-    }))
-});