Add m-esr52 at 52.6.0

9 files changed, 791 insertions, 0 deletions

diff --git a/toolkit/components/promiseworker/PromiseWorker.jsm b/toolkit/components/promiseworker/PromiseWorker.jsm
new file mode 100644
index 000000000..0c6e054a2
--- /dev/null
+++ b/toolkit/components/promiseworker/PromiseWorker.jsm
@@ -0,0 +1,390 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * A wrapper around ChromeWorker with extended capabilities designed
+ * to simplify main thread-to-worker thread asynchronous function calls.
+ *
+ * This wrapper:
+ * - groups requests and responses as a method `post` that returns a `Promise`;
+ * - ensures that exceptions thrown on the worker thread are correctly deserialized;
+ * - provides some utilities for benchmarking various operations.
+ *
+ * Generally, you should use PromiseWorker.jsm along with its worker-side
+ * counterpart PromiseWorker.js.
+ */
+
+"use strict";
+
+this.EXPORTED_SYMBOLS = ["BasePromiseWorker"];
+
+const Cu = Components.utils;
+const Ci = Components.interfaces;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
+
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+  "resource://gre/modules/Task.jsm");
+
+/**
+ * An implementation of queues (FIFO).
+ *
+ * The current implementation uses one array, runs in O(n ^ 2), and is optimized
+ * for the case in which queues are generally short.
+ */
+function Queue() {
+  this._array = [];
+}
+Queue.prototype = {
+  pop: function pop() {
+    return this._array.shift();
+  },
+  push: function push(x) {
+    return this._array.push(x);
+  },
+  isEmpty: function isEmpty() {
+    return this._array.length == 0;
+  }
+};
+
+/**
+ * Constructors for decoding standard exceptions received from the
+ * worker.
+ */
+const EXCEPTION_CONSTRUCTORS = {
+  EvalError: function(error) {
+    let result = new EvalError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  InternalError: function(error) {
+    let result = new InternalError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  RangeError: function(error) {
+    let result = new RangeError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  ReferenceError: function(error) {
+    let result = new ReferenceError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  SyntaxError: function(error) {
+    let result = new SyntaxError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  TypeError: function(error) {
+    let result = new TypeError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  URIError: function(error) {
+    let result = new URIError(error.message, error.fileName, error.lineNumber);
+    result.stack = error.stack;
+    return result;
+  },
+  StopIteration: function() {
+    return StopIteration;
+  }
+};
+
+/**
+ * An object responsible for dispatching messages to a chrome worker
+ * and routing the responses.
+ *
+ * Instances of this constructor who need logging may provide a method
+ * `log: function(...args) { ... }` in charge of printing out (or
+ * discarding) logs.
+ *
+ * Instances of this constructor may add exception handlers to
+ * `this.ExceptionHandlers`, if they need to handle custom exceptions.
+ *
+ * @param {string} url The url containing the source code for this worker,
+ * as in constructor ChromeWorker.
+ *
+ * @constructor
+ */
+this.BasePromiseWorker = function(url) {
+  if (typeof url != "string") {
+    throw new TypeError("Expecting a string");
+  }
+  this._url = url;
+
+  /**
+   * A set of methods, with the following
+   *
+   * ConstructorName: function({message, fileName, lineNumber}) {
+   *   // Construct a new instance of ConstructorName based on
+   *   // `message`, `fileName`, `lineNumber`
+   * }
+   *
+   * By default, this covers EvalError, InternalError, RangeError,
+   * ReferenceError, SyntaxError, TypeError, URIError, StopIteration.
+   */
+  this.ExceptionHandlers = Object.create(EXCEPTION_CONSTRUCTORS);
+
+  /**
+   * The queue of deferred, waiting for the completion of their
+   * respective job by the worker.
+   *
+   * Each item in the list may contain an additional field |closure|,
+   * used to store strong references to value that must not be
+   * garbage-collected before the reply has been received (e.g.
+   * arrays).
+   *
+   * @type {Queue<{deferred:deferred, closure:*=}>}
+   */
+  this._queue = new Queue();
+
+  /**
+   * The number of the current message.
+   *
+   * Used for debugging purposes.
+   */
+  this._id = 0;
+
+  /**
+   * The instant at which the worker was launched.
+   */
+  this.launchTimeStamp = null;
+
+  /**
+   * Timestamps provided by the worker for statistics purposes.
+   */
+  this.workerTimeStamps = null;
+};
+this.BasePromiseWorker.prototype = {
+  log: function() {
+    // By Default, ignore all logs.
+  },
+
+  /**
+   * Instantiate the worker lazily.
+   */
+  get _worker() {
+    delete this._worker;
+    let worker = new ChromeWorker(this._url);
+    Object.defineProperty(this, "_worker", {value:
+      worker
+    });
+
+    // We assume that we call to _worker for the purpose of calling
+    // postMessage().
+    this.launchTimeStamp = Date.now();
+
+    /**
+     * Receive errors that have been serialized by the built-in mechanism
+     * of DOM/Chrome Workers.
+     *
+     * PromiseWorker.js  knows how  to  serialize a  number of  errors
+     * without    losing   information.    These   are    treated   by
+     * |worker.onmessage|.   However, for  other  errors,  we rely  on
+     * DOM's mechanism  for serializing errors, which  transmits these
+     * errors through |worker.onerror|.
+     *
+     * @param {Error} error Some JS error.
+     */
+    worker.onerror = error => {
+      this.log("Received uncaught error from worker", error.message, error.filename, error.lineno);
+      error.preventDefault();
+      let {deferred} = this._queue.pop();
+      deferred.reject(error);
+    };
+
+    /**
+     * Receive messages from the worker, propagate them to the listeners.
+     *
+     * Messages must have one of the following shapes:
+     * - {ok: some_value} in case of success
+     * - {fail: some_error} in case of error, where
+     *    some_error is an instance of |PromiseWorker.WorkerError|
+     *
+     * Messages may also contain a field |id| to help
+     * with debugging.
+     *
+     * Messages may also optionally contain a field |durationMs|, holding
+     * the duration of the function call in milliseconds.
+     *
+     * @param {*} msg The message received from the worker.
+     */
+    worker.onmessage = msg => {
+      this.log("Received message from worker", msg.data);
+      let handler = this._queue.pop();
+      let deferred = handler.deferred;
+      let data = msg.data;
+      if (data.id != handler.id) {
+        throw new Error("Internal error: expecting msg " + handler.id + ", " +
+                        " got " + data.id + ": " + JSON.stringify(msg.data));
+      }
+      if ("timeStamps" in data) {
+        this.workerTimeStamps = data.timeStamps;
+      }
+      if ("ok" in data) {
+        // Pass the data to the listeners.
+        deferred.resolve(data);
+      } else if ("fail" in data) {
+        // We have received an error that was serialized by the
+        // worker.
+        deferred.reject(new WorkerError(data.fail));
+      }
+    };
+    return worker;
+  },
+
+  /**
+   * Post a message to a worker.
+   *
+   * @param {string} fun The name of the function to call.
+   * @param {Array} args The arguments to pass to `fun`. If any
+   * of the arguments is a Promise, it is resolved before posting the
+   * message. If any of the arguments needs to be transfered instead
+   * of copied, this may be specified by making the argument an instance
+   * of `BasePromiseWorker.Meta` or by using the `transfers` argument.
+   * By convention, the last argument may be an object `options`
+   * with some of the following fields:
+   * - {number|null} outExecutionDuration A parameter to be filled with the
+   *   duration of the off main thread execution for this call.
+   * @param {*=} closure An object holding references that should not be
+   * garbage-collected before the message treatment is complete.
+   * @param {Array=} transfers An array of objects that should be transfered
+   * to the worker instead of being copied. If any of the objects is a Promise,
+   * it is resolved before posting the message.
+   *
+   * @return {promise}
+   */
+  post: function(fun, args, closure, transfers) {
+    return Task.spawn(function* postMessage() {
+      // Normalize in case any of the arguments is a promise
+      if (args) {
+        args = yield Promise.resolve(Promise.all(args));
+      }
+      if (transfers) {
+        transfers = yield Promise.resolve(Promise.all(transfers));
+      } else {
+        transfers = [];
+      }
+
+      if (args) {
+        // Extract `Meta` data
+        args = args.map(arg => {
+          if (arg instanceof BasePromiseWorker.Meta) {
+            if (arg.meta && "transfers" in arg.meta) {
+              transfers.push(...arg.meta.transfers);
+            }
+            return arg.data;
+          }
+          return arg;
+        });
+      }
+
+      let id = ++this._id;
+      let message = {fun: fun, args: args, id: id};
+      this.log("Posting message", message);
+      try {
+        this._worker.postMessage(message, ...[transfers]);
+      } catch (ex) {
+        if (typeof ex == "number") {
+          this.log("Could not post message", message, "due to xpcom error", ex);
+          // handle raw xpcom errors (see eg bug 961317)
+          throw new Components.Exception("Error in postMessage", ex);
+        }
+
+        this.log("Could not post message", message, "due to error", ex);
+        throw ex;
+      }
+
+      let deferred = Promise.defer();
+      this._queue.push({deferred:deferred, closure: closure, id: id});
+      this.log("Message posted");
+
+      let reply;
+      try {
+        this.log("Expecting reply");
+        reply = yield deferred.promise;
+      } catch (error) {
+        this.log("Got error", error);
+        reply = error;
+
+        if (error instanceof WorkerError) {
+          // We know how to deserialize most well-known errors
+          throw this.ExceptionHandlers[error.data.exn](error.data);
+        }
+
+        if (error instanceof ErrorEvent) {
+          // Other errors get propagated as instances of ErrorEvent
+          this.log("Error serialized by DOM", error.message, error.filename, error.lineno);
+          throw new Error(error.message, error.filename, error.lineno);
+        }
+
+        // We don't know about this kind of error
+        throw error;
+      }
+
+      // By convention, the last argument may be an object `options`.
+      let options = null;
+      if (args) {
+        options = args[args.length - 1];
+      }
+
+      // Check for duration and return result.
+      if (!options ||
+          typeof options !== "object" ||
+          !("outExecutionDuration" in options)) {
+        return reply.ok;
+      }
+      // If reply.durationMs is not present, just return the result,
+      // without updating durations (there was an error in the method
+      // dispatch).
+      if (!("durationMs" in reply)) {
+        return reply.ok;
+      }
+      // Bug 874425 demonstrates that two successive calls to Date.now()
+      // can actually produce an interval with negative duration.
+      // We assume that this is due to an operation that is so short
+      // that Date.now() is not monotonic, so we round this up to 0.
+      let durationMs = Math.max(0, reply.durationMs);
+      // Accumulate (or initialize) outExecutionDuration
+      if (typeof options.outExecutionDuration == "number") {
+        options.outExecutionDuration += durationMs;
+      } else {
+        options.outExecutionDuration = durationMs;
+      }
+      return reply.ok;
+
+    }.bind(this));
+  }
+};
+
+/**
+ * An error that has been serialized by the worker.
+ *
+ * @constructor
+ */
+function WorkerError(data) {
+  this.data = data;
+}
+
+/**
+ * A constructor used to send data to the worker thread while
+ * with special treatment (e.g. transmitting data instead of
+ * copying it).
+ *
+ * @param {object=} data The data to send to the caller thread.
+ * @param {object=} meta Additional instructions, as an object
+ * that may contain the following fields:
+ * - {Array} transfers An array of objects that should be transferred
+ *   instead of being copied.
+ *
+ * @constructor
+ */
+this.BasePromiseWorker.Meta = function(data, meta) {
+  this.data = data;
+  this.meta = meta;
+};
diff --git a/toolkit/components/promiseworker/moz.build b/toolkit/components/promiseworker/moz.build
new file mode 100644
index 000000000..44a90e679
--- /dev/null
+++ b/toolkit/components/promiseworker/moz.build
@@ -0,0 +1,18 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+DIRS += [
+    'worker'
+]
+
+EXTRA_JS_MODULES += [
+    'PromiseWorker.jsm',
+]
+
+XPCSHELL_TESTS_MANIFESTS += ['tests/xpcshell/xpcshell.ini']
+
+with Files('**'):
+    BUG_COMPONENT = ('Toolkit', 'Async Tooling')
diff --git a/toolkit/components/promiseworker/tests/xpcshell/.eslintrc.js b/toolkit/components/promiseworker/tests/xpcshell/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/promiseworker/tests/xpcshell/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/promiseworker/tests/xpcshell/data/chrome.manifest b/toolkit/components/promiseworker/tests/xpcshell/data/chrome.manifest
new file mode 100644
index 000000000..9e5dd29b2
--- /dev/null
+++ b/toolkit/components/promiseworker/tests/xpcshell/data/chrome.manifest
@@ -0,0 +1 @@
+content promiseworker ./
diff --git a/toolkit/components/promiseworker/tests/xpcshell/data/worker.js b/toolkit/components/promiseworker/tests/xpcshell/data/worker.js
new file mode 100644
index 000000000..b4750788b
--- /dev/null
+++ b/toolkit/components/promiseworker/tests/xpcshell/data/worker.js
@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Trivial worker definition
+
+importScripts("resource://gre/modules/workers/require.js");
+var PromiseWorker = require("resource://gre/modules/workers/PromiseWorker.js");
+
+var worker = new PromiseWorker.AbstractWorker();
+worker.dispatch = function(method, args = []) {
+  return Agent[method](...args);
+},
+worker.postMessage = function(...args) {
+  self.postMessage(...args);
+};
+worker.close = function() {
+  self.close();
+};
+worker.log = function(...args) {
+  dump("Worker: " + args.join(" ") + "\n");
+};
+self.addEventListener("message", msg => worker.handleMessage(msg));
+
+var Agent = {
+  bounce: function(...args) {
+    return args;
+  },
+
+  throwError: function(msg, ...args) {
+     throw new Error(msg);
+  },
+};
diff --git a/toolkit/components/promiseworker/tests/xpcshell/test_Promise.js b/toolkit/components/promiseworker/tests/xpcshell/test_Promise.js
new file mode 100644
index 000000000..70f49e92e
--- /dev/null
+++ b/toolkit/components/promiseworker/tests/xpcshell/test_Promise.js
@@ -0,0 +1,117 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/PromiseWorker.jsm", this);
+Cu.import("resource://gre/modules/Timer.jsm", this);
+
+// Worker must be loaded from a chrome:// uri, not a file://
+// uri, so we first need to load it.
+
+var WORKER_SOURCE_URI = "chrome://promiseworker/content/worker.js";
+do_load_manifest("data/chrome.manifest");
+var worker = new BasePromiseWorker(WORKER_SOURCE_URI);
+worker.log = function(...args) {
+  do_print("Controller: " + args.join(" "));
+};
+
+// Test that simple messages work
+add_task(function* test_simple_args() {
+  let message = ["test_simple_args", Math.random()];
+  let result = yield worker.post("bounce", message);
+  Assert.equal(JSON.stringify(result), JSON.stringify(message));
+});
+
+// Test that it works when we don't provide a message
+add_task(function* test_no_args() {
+  let result = yield worker.post("bounce");
+  Assert.equal(JSON.stringify(result), JSON.stringify([]));
+});
+
+// Test that messages with promise work
+add_task(function* test_promise_args() {
+  let message = ["test_promise_args", Promise.resolve(Math.random())];
+  let stringified = JSON.stringify((yield Promise.resolve(Promise.all(message))));
+  let result = yield worker.post("bounce", message);
+  Assert.equal(JSON.stringify(result), stringified);
+});
+
+// Test that messages with delayed promise work
+add_task(function* test_delayed_promise_args() {
+  let promise = new Promise(resolve => setTimeout(() => resolve(Math.random()), 10));
+  let message = ["test_delayed_promise_args", promise];
+  let stringified = JSON.stringify((yield Promise.resolve(Promise.all(message))));
+  let result = yield worker.post("bounce", message);
+  Assert.equal(JSON.stringify(result), stringified);
+});
+
+// Test that messages with rejected promise cause appropriate errors
+add_task(function* test_rejected_promise_args() {
+  let error = new Error();
+  let message = ["test_promise_args", Promise.reject(error)];
+  try {
+    yield worker.post("bounce", message);
+    do_throw("I shound have thrown an error by now");
+  } catch (ex) {
+    if (ex != error)
+      throw ex;
+    do_print("I threw the right error");
+  }
+});
+
+// Test that we can transfer to the worker using argument `transfer`
+add_task(function* test_transfer_args() {
+  let array = new Uint8Array(4);
+  for (let i = 0; i < 4; ++i) {
+    array[i] = i;
+  }
+  Assert.equal(array.buffer.byteLength, 4, "The buffer is not detached yet");
+
+  let result = (yield worker.post("bounce", [array.buffer], [], [array.buffer]))[0];
+
+  // Check that the buffer has been sent
+  Assert.equal(array.buffer.byteLength, 0, "The buffer has been detached");
+
+  // Check that the result is correct
+  Assert.equal(result.byteLength, 4, "The result has the right size");
+  let array2 = new Uint8Array(result);
+  for (let i = 0; i < 4; ++i) {
+    Assert.equal(array2[i], i);
+  }
+});
+
+// Test that we can transfer to the worker using an instance of `Meta`
+add_task(function* test_transfer_with_meta() {
+  let array = new Uint8Array(4);
+  for (let i = 0; i < 4; ++i) {
+    array[i] = i;
+  }
+  Assert.equal(array.buffer.byteLength, 4, "The buffer is not detached yet");
+
+  let message = new BasePromiseWorker.Meta(array, {transfers: [array.buffer]});
+  let result = (yield worker.post("bounce", [message]))[0];
+
+  // Check that the buffer has been sent
+  Assert.equal(array.buffer.byteLength, 0, "The buffer has been detached");
+
+  // Check that the result is correct
+  Assert.equal(Object.prototype.toString.call(result), "[object Uint8Array]",
+               "The result appears to be a Typed Array");
+  Assert.equal(result.byteLength, 4, "The result has the right size");
+
+  for (let i = 0; i < 4; ++i) {
+    Assert.equal(result[i], i);
+  }
+});
+
+add_task(function* test_throw_error() {
+  try {
+    yield worker.post("throwError", ["error message"]);
+    Assert.ok(false, "should have thrown");
+  } catch (ex) {
+    Assert.equal(ex.message, "Error: error message");
+  }
+});
diff --git a/toolkit/components/promiseworker/tests/xpcshell/xpcshell.ini b/toolkit/components/promiseworker/tests/xpcshell/xpcshell.ini
new file mode 100644
index 000000000..1efcd8c9e
--- /dev/null
+++ b/toolkit/components/promiseworker/tests/xpcshell/xpcshell.ini
@@ -0,0 +1,9 @@
+[DEFAULT]
+head=
+tail=
+skip-if = toolkit == 'android'
+support-files=
+  data/worker.js
+  data/chrome.manifest
+
+[test_Promise.js]
diff --git a/toolkit/components/promiseworker/worker/PromiseWorker.js b/toolkit/components/promiseworker/worker/PromiseWorker.js
new file mode 100644
index 000000000..ba4408c1a
--- /dev/null
+++ b/toolkit/components/promiseworker/worker/PromiseWorker.js
@@ -0,0 +1,206 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * A wrapper around `self` with extended capabilities designed
+ * to simplify main thread-to-worker thread asynchronous function calls.
+ *
+ * This wrapper:
+ * - groups requests and responses as a method `post` that returns a `Promise`;
+ * - ensures that exceptions thrown on the worker thread are correctly serialized;
+ * - provides some utilities for benchmarking various operations.
+ *
+ * Generally, you should use PromiseWorker.js along with its main thread-side
+ * counterpart PromiseWorker.jsm.
+ */
+
+"use strict";
+
+if (typeof Components != "undefined") {
+  throw new Error("This module is meant to be used from the worker thread");
+}
+if (typeof require == "undefined" || typeof module == "undefined") {
+  throw new Error("this module is meant to be imported using the implementation of require() at resource://gre/modules/workers/require.js");
+}
+
+importScripts("resource://gre/modules/workers/require.js");
+
+/**
+ * Built-in JavaScript exceptions that may be serialized without
+ * loss of information.
+ */
+const EXCEPTION_NAMES = {
+  EvalError: "EvalError",
+  InternalError: "InternalError",
+  RangeError: "RangeError",
+  ReferenceError: "ReferenceError",
+  SyntaxError: "SyntaxError",
+  TypeError: "TypeError",
+  URIError: "URIError",
+};
+
+/**
+ * A constructor used to return data to the caller thread while
+ * also executing some specific treatment (e.g. shutting down
+ * the current thread, transmitting data instead of copying it).
+ *
+ * @param {object=} data The data to return to the caller thread.
+ * @param {object=} meta Additional instructions, as an object
+ * that may contain the following fields:
+ * - {bool} shutdown If |true|, shut down the current thread after
+ *   having sent the result.
+ * - {Array} transfers An array of objects that should be transferred
+ *   instead of being copied.
+ *
+ * @constructor
+ */
+function Meta(data, meta) {
+  this.data = data;
+  this.meta = meta;
+}
+exports.Meta = Meta;
+
+/**
+ * Base class for a worker.
+ *
+ * Derived classes are expected to provide the following methods:
+ * {
+ *   dispatch: function(method, args) {
+ *     // Dispatch a call to method `method` with args `args`
+ *   },
+ *   log: function(...msg) {
+ *     // Log (or discard) messages (optional)
+ *   },
+ *   postMessage: function(message, ...transfers) {
+ *     // Post a message to the main thread
+ *   },
+ *   close: function() {
+ *     // Close the worker
+ *   }
+ * }
+ *
+ * By default, the AbstractWorker is not connected to a message port,
+ * hence will not receive anything.
+ *
+ * To connect it, use `onmessage`, as follows:
+ *   self.addEventListener("message", msg => myWorkerInstance.handleMessage(msg));
+ */
+function AbstractWorker(agent) {
+  this._agent = agent;
+}
+AbstractWorker.prototype = {
+  // Default logger: discard all messages
+  log: function() {
+  },
+
+  /**
+   * Handle a message.
+   */
+  handleMessage: function(msg) {
+    let data = msg.data;
+    this.log("Received message", data);
+    let id = data.id;
+
+    let start;
+    let options;
+    if (data.args) {
+      options = data.args[data.args.length - 1];
+    }
+    // If |outExecutionDuration| option was supplied, start measuring the
+    // duration of the operation.
+    if (options && typeof options === "object" && "outExecutionDuration" in options) {
+       start = Date.now();
+    }
+
+    let result;
+    let exn;
+    let durationMs;
+    let method = data.fun;
+    try {
+      this.log("Calling method", method);
+      result = this.dispatch(method, data.args);
+      this.log("Method", method, "succeeded");
+    } catch (ex) {
+      exn = ex;
+      this.log("Error while calling agent method", method, exn, exn.moduleStack || exn.stack || "");
+    }
+
+    if (start) {
+      // Record duration
+      durationMs = Date.now() - start;
+      this.log("Method took", durationMs, "ms");
+    }
+
+    // Now, post a reply, possibly as an uncaught error.
+    // We post this message from outside the |try ... catch| block
+    // to avoid capturing errors that take place during |postMessage| and
+    // built-in serialization.
+    if (!exn) {
+      this.log("Sending positive reply", result, "id is", id);
+      if (result instanceof Meta) {
+        if ("transfers" in result.meta) {
+          // Take advantage of zero-copy transfers
+          this.postMessage({ok: result.data, id: id, durationMs: durationMs},
+            result.meta.transfers);
+        } else {
+          this.postMessage({ok: result.data, id:id, durationMs: durationMs});
+        }
+        if (result.meta.shutdown || false) {
+          // Time to close the worker
+          this.close();
+        }
+      } else {
+        this.postMessage({ok: result, id:id, durationMs: durationMs});
+      }
+    } else if (exn.constructor.name in EXCEPTION_NAMES) {
+      // Rather than letting the DOM mechanism [de]serialize built-in
+      // JS errors, which loses lots of information (in particular,
+      // the constructor name, the moduleName and the moduleStack),
+      // we [de]serialize them manually with a little more care.
+      this.log("Sending back exception", exn.constructor.name, "id is", id);
+      let error = {
+        exn: exn.constructor.name,
+        message: exn.message,
+        fileName: exn.moduleName || exn.fileName,
+        lineNumber: exn.lineNumber,
+        stack: exn.moduleStack
+      };
+      this.postMessage({fail: error, id: id, durationMs: durationMs});
+    } else if (exn == StopIteration) {
+      // StopIteration is a well-known singleton, and requires a
+      // slightly different treatment.
+      this.log("Sending back StopIteration, id is", id);
+      let error = {
+        exn: "StopIteration"
+      };
+      this.postMessage({fail: error, id: id, durationMs: durationMs});
+    } else if ("toMsg" in exn) {
+      // Extension mechanism for exception [de]serialization. We
+      // assume that any exception with a method `toMsg()` knows how
+      // to serialize itself. The other side is expected to have
+      // registered a deserializer using the `ExceptionHandlers`
+      // object.
+      this.log("Sending back an error that knows how to serialize itself", exn, "id is", id);
+      let msg = exn.toMsg();
+      this.postMessage({fail: msg, id:id, durationMs: durationMs});
+    } else {
+      // If we encounter an exception for which we have no
+      // serialization mechanism in place, we have no choice but to
+      // let the DOM handle said [de]serialization. We can just
+      // attempt to mitigate the data loss by injecting `moduleName` and
+      // `moduleStack`.
+      this.log("Sending back regular error", exn, exn.moduleStack || exn.stack, "id is", id);
+
+      try {
+        // Attempt to introduce human-readable filename and stack
+        exn.filename = exn.moduleName;
+        exn.stack = exn.moduleStack;
+      } catch (_) {
+        // Nothing we can do
+      }
+      throw exn;
+    }
+  }
+};
+exports.AbstractWorker = AbstractWorker;
diff --git a/toolkit/components/promiseworker/worker/moz.build b/toolkit/components/promiseworker/worker/moz.build
new file mode 100644
index 000000000..305d49838
--- /dev/null
+++ b/toolkit/components/promiseworker/worker/moz.build
@@ -0,0 +1,9 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXTRA_JS_MODULES.workers = [
+    'PromiseWorker.js',
+]