Add m-esr52 at 52.6.0

1 files changed, 334 insertions, 0 deletions

diff --git a/devtools/shared/ThreadSafeDevToolsUtils.js b/devtools/shared/ThreadSafeDevToolsUtils.js
new file mode 100644
index 000000000..55a98cf35
--- /dev/null
+++ b/devtools/shared/ThreadSafeDevToolsUtils.js
@@ -0,0 +1,334 @@
+/* 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/. */
+
+"use strict";
+
+/**
+ * General utilities used throughout devtools that can also be used in
+ * workers.
+ */
+
+/**
+ * Immutably reduce the given `...objs` into one object. The reduction is
+ * applied from left to right, so `immutableUpdate({ a: 1 }, { a: 2 })` will
+ * result in `{ a: 2 }`. The resulting object is frozen.
+ *
+ * Example usage:
+ *
+ *     const original = { foo: 1, bar: 2, baz: 3 };
+ *     const modified = immutableUpdate(original, { baz: 0, bang: 4 });
+ *
+ *     // We get the new object that we expect...
+ *     assert(modified.baz === 0);
+ *     assert(modified.bang === 4);
+ *
+ *     // However, the original is not modified.
+ *     assert(original.baz === 2);
+ *     assert(original.bang === undefined);
+ *
+ * @param {...Object} ...objs
+ * @returns {Object}
+ */
+exports.immutableUpdate = function (...objs) {
+  return Object.freeze(Object.assign({}, ...objs));
+};
+
+/**
+ * Utility function for updating an object with the properties of
+ * other objects.
+ *
+ * DEPRECATED: Just use Object.assign() instead!
+ *
+ * @param aTarget Object
+ *        The object being updated.
+ * @param aNewAttrs Object
+ *        The rest params are objects to update aTarget with. You
+ *        can pass as many as you like.
+ */
+exports.update = function update(target, ...args) {
+  for (let attrs of args) {
+    for (let key in attrs) {
+      let desc = Object.getOwnPropertyDescriptor(attrs, key);
+
+      if (desc) {
+        Object.defineProperty(target, key, desc);
+      }
+    }
+  }
+  return target;
+};
+
+/**
+ * Utility function for getting the values from an object as an array
+ *
+ * @param object Object
+ *        The object to iterate over
+ */
+exports.values = function values(object) {
+  return Object.keys(object).map(k => object[k]);
+};
+
+/**
+ * Report that |who| threw an exception, |exception|.
+ */
+exports.reportException = function reportException(who, exception) {
+  const msg = `${who} threw an exception: ${exports.safeErrorString(exception)}`;
+  dump(msg + "\n");
+
+  if (typeof console !== "undefined" && console && console.error) {
+    console.error(msg);
+  }
+};
+
+/**
+ * Given a handler function that may throw, return an infallible handler
+ * function that calls the fallible handler, and logs any exceptions it
+ * throws.
+ *
+ * @param handler function
+ *      A handler function, which may throw.
+ * @param aName string
+ *      A name for handler, for use in error messages. If omitted, we use
+ *      handler.name.
+ *
+ * (SpiderMonkey does generate good names for anonymous functions, but we
+ * don't have a way to get at them from JavaScript at the moment.)
+ */
+exports.makeInfallible = function (handler, name = handler.name) {
+  return function (/* arguments */) {
+    try {
+      return handler.apply(this, arguments);
+    } catch (ex) {
+      let who = "Handler function";
+      if (name) {
+        who += " " + name;
+      }
+      exports.reportException(who, ex);
+      return undefined;
+    }
+  };
+};
+
+/**
+ * Turn the |error| into a string, without fail.
+ *
+ * @param {Error|any} error
+ */
+exports.safeErrorString = function (error) {
+  try {
+    let errorString = error.toString();
+    if (typeof errorString == "string") {
+      // Attempt to attach a stack to |errorString|. If it throws an error, or
+      // isn't a string, don't use it.
+      try {
+        if (error.stack) {
+          let stack = error.stack.toString();
+          if (typeof stack == "string") {
+            errorString += "\nStack: " + stack;
+          }
+        }
+      } catch (ee) { }
+
+      // Append additional line and column number information to the output,
+      // since it might not be part of the stringified error.
+      if (typeof error.lineNumber == "number" && typeof error.columnNumber == "number") {
+        errorString += "Line: " + error.lineNumber + ", column: " + error.columnNumber;
+      }
+
+      return errorString;
+    }
+  } catch (ee) { }
+
+  // We failed to find a good error description, so do the next best thing.
+  return Object.prototype.toString.call(error);
+};
+
+/**
+ * Interleaves two arrays element by element, returning the combined array, like
+ * a zip. In the case of arrays with different sizes, undefined values will be
+ * interleaved at the end along with the extra values of the larger array.
+ *
+ * @param Array a
+ * @param Array b
+ * @returns Array
+ *          The combined array, in the form [a1, b1, a2, b2, ...]
+ */
+exports.zip = function (a, b) {
+  if (!b) {
+    return a;
+  }
+  if (!a) {
+    return b;
+  }
+  const pairs = [];
+  for (let i = 0, aLength = a.length, bLength = b.length;
+       i < aLength || i < bLength;
+       i++) {
+    pairs.push([a[i], b[i]]);
+  }
+  return pairs;
+};
+
+/**
+ * Converts an object into an array with 2-element arrays as key/value
+ * pairs of the object. `{ foo: 1, bar: 2}` would become
+ * `[[foo, 1], [bar 2]]` (order not guaranteed).
+ *
+ * @param object obj
+ * @returns array
+ */
+exports.entries = function entries(obj) {
+  return Object.keys(obj).map(k => [k, obj[k]]);
+};
+
+/*
+ * Takes an array of 2-element arrays as key/values pairs and
+ * constructs an object using them.
+ */
+exports.toObject = function (arr) {
+  const obj = {};
+  for (let [k, v] of arr) {
+    obj[k] = v;
+  }
+  return obj;
+};
+
+/**
+ * Composes the given functions into a single function, which will
+ * apply the results of each function right-to-left, starting with
+ * applying the given arguments to the right-most function.
+ * `compose(foo, bar, baz)` === `args => foo(bar(baz(args)))`
+ *
+ * @param ...function funcs
+ * @returns function
+ */
+exports.compose = function compose(...funcs) {
+  return (...args) => {
+    const initialValue = funcs[funcs.length - 1](...args);
+    const leftFuncs = funcs.slice(0, -1);
+    return leftFuncs.reduceRight((composed, f) => f(composed),
+                                 initialValue);
+  };
+};
+
+/**
+ * Return true if `thing` is a generator function, false otherwise.
+ */
+exports.isGenerator = function (fn) {
+  if (typeof fn !== "function") {
+    return false;
+  }
+  let proto = Object.getPrototypeOf(fn);
+  if (!proto) {
+    return false;
+  }
+  let ctor = proto.constructor;
+  if (!ctor) {
+    return false;
+  }
+  return ctor.name == "GeneratorFunction";
+};
+
+/**
+ * Return true if `thing` is a Promise or then-able, false otherwise.
+ */
+exports.isPromise = function (p) {
+  return p && typeof p.then === "function";
+};
+
+/**
+ * Return true if `thing` is a SavedFrame, false otherwise.
+ */
+exports.isSavedFrame = function (thing) {
+  return Object.prototype.toString.call(thing) === "[object SavedFrame]";
+};
+
+/**
+ * Return true iff `thing` is a `Set` object (possibly from another global).
+ */
+exports.isSet = function (thing) {
+  return Object.prototype.toString.call(thing) === "[object Set]";
+};
+
+/**
+ * Given a list of lists, flatten it. Only flattens one level; does not
+ * recursively flatten all levels.
+ *
+ * @param {Array<Array<Any>>} lists
+ * @return {Array<Any>}
+ */
+exports.flatten = function (lists) {
+  return Array.prototype.concat.apply([], lists);
+};
+
+/**
+ * Returns a promise that is resolved or rejected when all promises have settled
+ * (resolved or rejected).
+ *
+ * This differs from Promise.all, which will reject immediately after the first
+ * rejection, instead of waiting for the remaining promises to settle.
+ *
+ * @param values
+ *        Iterable of promises that may be pending, resolved, or rejected. When
+ *        when all promises have settled (resolved or rejected), the returned
+ *        promise will be resolved or rejected as well.
+ *
+ * @return A new promise that is fulfilled when all values have settled
+ *         (resolved or rejected). Its resolution value will be an array of all
+ *         resolved values in the given order, or undefined if values is an
+ *         empty array. The reject reason will be forwarded from the first
+ *         promise in the list of given promises to be rejected.
+ */
+exports.settleAll = values => {
+  if (values === null || typeof (values[Symbol.iterator]) != "function") {
+    throw new Error("settleAll() expects an iterable.");
+  }
+
+  return new Promise((resolve, reject) => {
+    values = Array.isArray(values) ? values : [...values];
+    let countdown = values.length;
+    let resolutionValues = new Array(countdown);
+    let rejectionValue;
+    let rejectionOccurred = false;
+
+    if (!countdown) {
+      resolve(resolutionValues);
+      return deferred.promise;
+    }
+
+    function checkForCompletion() {
+      if (--countdown > 0) {
+        return;
+      }
+      if (!rejectionOccurred) {
+        resolve(resolutionValues);
+      } else {
+        reject(rejectionValue);
+      }
+    }
+
+    for (let i = 0; i < values.length; i++) {
+      let index = i;
+      let value = values[i];
+      let resolver = result => {
+        resolutionValues[index] = result;
+        checkForCompletion();
+      };
+      let rejecter = error => {
+        if (!rejectionOccurred) {
+          rejectionValue = error;
+          rejectionOccurred = true;
+        }
+        checkForCompletion();
+      };
+
+      if (value && typeof (value.then) == "function") {
+        value.then(resolver, rejecter);
+      } else {
+        // Given value is not a promise, forward it as a resolution value.
+        resolver(value);
+      }
+    }
+  });
+};