initial revision

69 files changed, 13128 insertions, 0 deletions

diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/api-utils.js b/tools/addon-sdk-1.3/packages/api-utils/lib/api-utils.js
new file mode 100644
index 0000000..17d18cc
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/api-utils.js
@@ -0,0 +1,186 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Drew Willcoxon <adw@mozilla.com> (Original Author)
+ *   Edward Lee <edilee@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// The possible return values of getTypeOf.
+const VALID_TYPES = [
+  "array",
+  "boolean",
+  "function",
+  "null",
+  "number",
+  "object",
+  "string",
+  "undefined",
+];
+
+/**
+ * Returns a function C that creates instances of privateCtor.  C may be called
+ * with or without the new keyword.  The prototype of each instance returned
+ * from C is C.prototype, and C.prototype is an object whose prototype is
+ * privateCtor.prototype.  Instances returned from C will therefore be instances
+ * of both C and privateCtor.  Additionally, the constructor of each instance
+ * returned from C is C.
+ *
+ * @param  privateCtor
+ *         A constructor.
+ * @return A function that makes new instances of privateCtor.
+ */
+exports.publicConstructor = function publicConstructor(privateCtor) {
+  function PublicCtor() {
+    let obj = { constructor: PublicCtor, __proto__: PublicCtor.prototype };
+    memory.track(obj, privateCtor.name);
+    privateCtor.apply(obj, arguments);
+    return obj;
+  }
+  PublicCtor.prototype = { __proto__: privateCtor.prototype };
+  return PublicCtor;
+};
+
+/**
+ * Returns a validated options dictionary given some requirements.  If any of
+ * the requirements are not met, an exception is thrown.
+ *
+ * @param  options
+ *         An object, the options dictionary to validate.  It's not modified.
+ *         If it's null or otherwise falsey, an empty object is assumed.
+ * @param  requirements
+ *         An object whose keys are the expected keys in options.  Any key in
+ *         options that is not present in requirements is ignored.  Each value
+ *         in requirements is itself an object describing the requirements of
+ *         its key.  There are four optional keys in this object:
+ *           map: A function that's passed the value of the key in options.
+ *                map's return value is taken as the key's value in the final
+ *                validated options, is, and ok.  If map throws an exception
+ *                it's caught and discarded, and the key's value is its value in
+ *                options.
+ *           is:  An array containing any number of the typeof type names.  If
+ *                the key's value is none of these types, it fails validation.
+ *                Arrays and null are identified by the special type names
+ *                "array" and "null"; "object" will not match either.  No type
+ *                coercion is done.
+ *           ok:  A function that's passed the key's value.  If it returns
+ *                false, the value fails validation.
+ *           msg: If the key's value fails validation, an exception is thrown.
+ *                This string will be used as its message.  If undefined, a
+ *                generic message is used, unless is is defined, in which case
+ *                the message will state that the value needs to be one of the
+ *                given types.
+ * @return An object whose keys are those keys in requirements that are also in
+ *         options and whose values are the corresponding return values of map
+ *         or the corresponding values in options.  Note that any keys not
+ *         shared by both requirements and options are not in the returned
+ *         object.
+ */
+exports.validateOptions = function validateOptions(options, requirements) {
+  options = options || {};
+  let validatedOptions = {};
+  let mapThrew = false;
+
+  for (let [key, req] in Iterator(requirements)) {
+    let [optsVal, keyInOpts] = (key in options) ?
+                               [options[key], true] :
+                               [undefined, false];
+    if (req.map) {
+      try {
+        optsVal = req.map(optsVal);
+      }
+      catch (err) {
+        mapThrew = true;
+      }
+    }
+    if (req.is) {
+      // Sanity check the caller's type names.
+      req.is.forEach(function (typ) {
+        if (VALID_TYPES.indexOf(typ) < 0) {
+          let msg = 'Internal error: invalid requirement type "' + typ + '".';
+          throw new Error(msg);
+        }
+      });
+      if (req.is.indexOf(getTypeOf(optsVal)) < 0)
+        throw requirementError(key, req);
+    }
+    if (req.ok && !req.ok(optsVal))
+      throw requirementError(key, req);
+
+    if (keyInOpts || (req.map && !mapThrew))
+      validatedOptions[key] = optsVal;
+  }
+
+  return validatedOptions;
+};
+
+exports.addIterator = function addIterator(obj, keysValsGenerator) {
+  obj.__iterator__ = function(keysOnly, keysVals) {
+    let keysValsIterator = keysValsGenerator.call(this);
+
+    // "for (.. in ..)" gets only keys, "for each (.. in ..)" gets values,
+    // and "for (.. in Iterator(..))" gets [key, value] pairs.
+    let index = keysOnly ? 0 : 1;
+    while (true)
+      yield keysVals ? keysValsIterator.next() : keysValsIterator.next()[index];
+  };
+};
+
+// Similar to typeof, except arrays and null are identified by "array" and
+// "null", not "object".
+let getTypeOf = exports.getTypeOf = function getTypeOf(val) {
+  let typ = typeof(val);
+  if (typ === "object") {
+    if (!val)
+      return "null";
+    if (Array.isArray(val))
+      return "array";
+  }
+  return typ;
+}
+
+// Returns a new Error with a nice message.
+function requirementError(key, requirement) {
+  let msg = requirement.msg;
+  if (!msg) {
+    msg = 'The option "' + key + '" ';
+    msg += requirement.is ?
+           "must be one of the following types: " + requirement.is.join(", ") :
+           "is invalid.";
+  }
+  return new Error(msg);
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/app-strings.js b/tools/addon-sdk-1.3/packages/api-utils/lib/app-strings.js
new file mode 100644
index 0000000..120c26e
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/app-strings.js
@@ -0,0 +1,95 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is String Bundle.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2008
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Myk Melez <myk@mozilla.org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci} = require("chrome");
+const apiUtils = require("./api-utils");
+
+/**
+ * A bundle of strings.
+ *
+ * @param url {String}
+ *        the URL of the string bundle
+ */
+exports.StringBundle = apiUtils.publicConstructor(function StringBundle(url) {
+
+  let stringBundle = Cc["@mozilla.org/intl/stringbundle;1"].
+                     getService(Ci.nsIStringBundleService).
+                     createBundle(url);
+
+  this.__defineGetter__("url", function () url);
+
+  /**
+   * Get a string from the bundle.
+   *
+   * @param name {String}
+   *        the name of the string to get
+   * @param args {array} [optional]
+   *        an array of arguments that replace occurrences of %S in the string
+   *
+   * @returns {String} the value of the string
+   */
+  this.get = function strings_get(name, args) {
+    try {
+      if (args)
+        return stringBundle.formatStringFromName(name, args, args.length);
+      else
+        return stringBundle.GetStringFromName(name);
+    }
+    catch(ex) {
+      // f.e. "Component returned failure code: 0x80004005 (NS_ERROR_FAILURE)
+      // [nsIStringBundle.GetStringFromName]"
+      throw new Error("String '" + name + "' could not be retrieved from the " +
+                      "bundle due to an unknown error (it doesn't exist?).");
+    }
+  },
+
+  /**
+   * Iterate the strings in the bundle.
+   *
+   */
+  apiUtils.addIterator(
+    this,
+    function keysValsGen() {
+      let enumerator = stringBundle.getSimpleEnumeration();
+      while (enumerator.hasMoreElements()) {
+        let elem = enumerator.getNext().QueryInterface(Ci.nsIPropertyElement);
+        yield [elem.key, elem.value];
+      }
+    }
+  );
+});
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/array.js b/tools/addon-sdk-1.3/packages/api-utils/lib/array.js
new file mode 100644
index 0000000..a41acdd
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/array.js
@@ -0,0 +1,102 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+/**
+ * Returns `true` if given `array` contain given `element` or `false`
+ * otherwise.
+ * @param {Array} array
+ *    Target array.
+ * @param {Object|String|Number|Boolean} element
+ *    Element being looked up.
+ * @returns {Boolean}
+ */
+var has = exports.has = function has(array, element) {
+  // shorter and faster equivalent of `array.indexOf(element) >= 0`
+  return !!~array.indexOf(element);
+};
+
+/**
+ * Adds given `element` to the given `array` if it does not contain it yet.
+ * `true` is returned if element was added otherwise `false` is returned.
+ * @param {Array} array
+ *    Target array.
+ * @param {Object|String|Number|Boolean} element
+ *    Element to be added.
+ * @returns {Boolean}
+ */
+var add = exports.add = function add(array, element) {
+  var result;
+  if ((result = !has(array, element)))
+    array.push(element);
+
+  return result;
+};
+
+/**
+ * Removes first occurrence of the given `element` from the given `array`. If
+ * `array` does not contain given `element` `false` is returned otherwise
+ * `true` is returned.
+ * @param {Array} array
+ *    Target array.
+ * @param {Object|String|Number|Boolean} element
+ *    Element to be removed.
+ * @returns {Boolean}
+ */
+exports.remove = function remove(array, element) {
+  var result;
+  if ((result = has(array, element)))
+    array.splice(array.indexOf(element), 1);
+
+  return result;
+};
+
+/**
+ * Produces a duplicate-free version of the given `array`.
+ * @param {Array} array
+ *    Source array.
+ * @returns {Array}
+ */
+exports.unique = function unique(array) {
+  var value = [];
+  return array.forEach(function(element) {
+    add(value, element);
+  });
+  return value;
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/byte-streams.js b/tools/addon-sdk-1.3/packages/api-utils/lib/byte-streams.js
new file mode 100644
index 0000000..b44357e
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/byte-streams.js
@@ -0,0 +1,135 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et filetype=javascript
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Drew Willcoxon <adw@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+exports.ByteReader = ByteReader;
+exports.ByteWriter = ByteWriter;
+
+const {Cc, Ci} = require("chrome");
+
+// This just controls the maximum number of bytes we read in at one time.
+const BUFFER_BYTE_LEN = 0x8000;
+
+function ByteReader(inputStream) {
+  const self = this;
+
+  let stream = Cc["@mozilla.org/binaryinputstream;1"].
+               createInstance(Ci.nsIBinaryInputStream);
+  stream.setInputStream(inputStream);
+
+  let manager = new StreamManager(this, stream);
+
+  this.read = function ByteReader_read(numBytes) {
+    manager.ensureOpened();
+    if (typeof(numBytes) !== "number")
+      numBytes = Infinity;
+
+    let data = "";
+    let read = 0;
+    try {
+      while (true) {
+        let avail = stream.available();
+        let toRead = Math.min(numBytes - read, avail, BUFFER_BYTE_LEN);
+        if (toRead <= 0)
+          break;
+        data += stream.readBytes(toRead);
+        read += toRead;
+      }
+    }
+    catch (err) {
+      throw new Error("Error reading from stream: " + err);
+    }
+
+    return data;
+  };
+}
+
+function ByteWriter(outputStream) {
+  const self = this;
+
+  let stream = Cc["@mozilla.org/binaryoutputstream;1"].
+               createInstance(Ci.nsIBinaryOutputStream);
+  stream.setOutputStream(outputStream);
+
+  let manager = new StreamManager(this, stream);
+
+  this.write = function ByteWriter_write(str) {
+    manager.ensureOpened();
+    try {
+      stream.writeBytes(str, str.length);
+    }
+    catch (err) {
+      throw new Error("Error writing to stream: " + err);
+    }
+  };
+}
+
+
+// This manages the lifetime of stream, a ByteReader or ByteWriter.  It defines
+// closed and close() on stream and registers an unload listener that closes
+// rawStream if it's still opened.  It also provides ensureOpened(), which
+// throws an exception if the stream is closed.
+function StreamManager(stream, rawStream) {
+  const self = this;
+  this.rawStream = rawStream;
+  this.opened = true;
+
+  stream.__defineGetter__("closed", function stream_closed() {
+    return !self.opened;
+  });
+
+  stream.close = function stream_close() {
+    self.ensureOpened();
+    self.unload();
+  };
+
+  require("./unload").ensure(this);
+}
+
+StreamManager.prototype = {
+  ensureOpened: function StreamManager_ensureOpened() {
+    if (!this.opened)
+      throw new Error("The stream is closed and cannot be used.");
+  },
+  unload: function StreamManager_unload() {
+    this.rawStream.close();
+    this.opened = false;
+  }
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/collection.js b/tools/addon-sdk-1.3/packages/api-utils/lib/collection.js
new file mode 100644
index 0000000..5525a5a
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/collection.js
@@ -0,0 +1,141 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Drew Willcoxon <adw@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+exports.Collection = Collection;
+
+/**
+ * Adds a collection property to the given object.  Setting the property to a
+ * scalar value empties the collection and adds the value.  Setting it to an
+ * array empties the collection and adds all the items in the array.
+ *
+ * @param obj
+ *        The property will be defined on this object.
+ * @param propName
+ *        The name of the property.
+ * @param array
+ *        If given, this will be used as the collection's backing array.
+ */
+exports.addCollectionProperty = function addCollProperty(obj, propName, array) {
+  array = array || [];
+  let publicIface = new Collection(array);
+
+  obj.__defineSetter__(propName, function (itemOrItems) {
+    array.splice(0, array.length);
+    publicIface.add(itemOrItems);
+  });
+
+  obj.__defineGetter__(propName, function () {
+    return publicIface;
+  });
+};
+
+/**
+ * A collection is ordered, like an array, but its items are unique, like a set.
+ *
+ * @param array
+ *        The collection is backed by an array.  If this is given, it will be
+ *        used as the backing array.  This way the caller can fully control the
+ *        collection.  Otherwise a new empty array will be used, and no one but
+ *        the collection will have access to it.
+ */
+function Collection(array) {
+  array = array || [];
+
+  /**
+   * Provides iteration over the collection.  Items are yielded in the order
+   * they were added.
+   */
+  this.__iterator__ = function Collection___iterator__() {
+    let items = array.slice();
+    for (let i = 0; i < items.length; i++)
+      yield items[i];
+  };
+
+  /**
+   * The number of items in the collection.
+   */
+  this.__defineGetter__("length", function Collection_get_length() {
+    return array.length;
+  });
+
+  /**
+   * Adds a single item or an array of items to the collection.  Any items
+   * already contained in the collection are ignored.
+   *
+   * @param  itemOrItems
+   *         An item or array of items.
+   * @return The collection.
+   */
+  this.add = function Collection_add(itemOrItems) {
+    let items = toArray(itemOrItems);
+    for (let i = 0; i < items.length; i++) {
+      let item = items[i];
+      if (array.indexOf(item) < 0)
+        array.push(item);
+    }
+    return this;
+  };
+
+  /**
+   * Removes a single item or an array of items from the collection.  Any items
+   * not contained in the collection are ignored.
+   *
+   * @param  itemOrItems
+   *         An item or array of items.
+   * @return The collection.
+   */
+  this.remove = function Collection_remove(itemOrItems) {
+    let items = toArray(itemOrItems);
+    for (let i = 0; i < items.length; i++) {
+      let idx = array.indexOf(items[i]);
+      if (idx >= 0)
+        array.splice(idx, 1);
+    }
+    return this;
+  };
+};
+
+function toArray(itemOrItems) {
+  let isArr = itemOrItems &&
+              itemOrItems.constructor &&
+              itemOrItems.constructor.name === "Array";
+  return isArr ? itemOrItems : [itemOrItems];
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/content.js b/tools/addon-sdk-1.3/packages/api-utils/lib/content.js
new file mode 100644
index 0000000..a46a5ff
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/content.js
@@ -0,0 +1,44 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+exports.Loader = require('./content/loader').Loader;
+exports.Symbiont = require('./content/symbiont').Symbiont;
+exports.Worker = require('./content/worker').Worker;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/content/content-proxy.js b/tools/addon-sdk-1.3/packages/api-utils/lib/content/content-proxy.js
new file mode 100644
index 0000000..ae1222f
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/content/content-proxy.js
@@ -0,0 +1,798 @@
+const { Ci, Cc } = require("chrome");
+const xulApp = require("xul-app");
+
+/**
+ * Access key that allows privileged code to unwrap proxy wrappers through 
+ * valueOf:
+ *   let xpcWrapper = proxyWrapper.valueOf(UNWRAP_ACCESS_KEY);
+ */
+const UNWRAP_ACCESS_KEY = {};
+exports.UNWRAP_ACCESS_KEY = UNWRAP_ACCESS_KEY;
+
+ /**
+ * Returns a closure that wraps arguments before calling the given function,
+ * which can be given to native functions that accept a function, such that when
+ * the closure is called, the given function is called with wrapped arguments.
+ *
+ * @param fun {Function}
+ *        the function for which to create a closure wrapping its arguments
+ * @param obj {Object}
+ *        target object from which `fun` comes from
+ *        (optional, for debugging purpose)
+ * @param name {String}
+ *        name of the attribute from which `fun` is binded on `obj`
+ *        (optional, for debugging purpose)
+ *
+ * Example:
+ *   function contentScriptListener(event) {}
+ *   let wrapper = ContentScriptFunctionWrapper(contentScriptListener);
+ *   xray.addEventListener("...", wrapper, false);
+ * -> Allow to `event` to be wrapped
+ */
+function ContentScriptFunctionWrapper(fun, obj, name) {
+  if ("___proxy" in fun && typeof fun.___proxy == "function")
+    return fun.___proxy;
+  
+  let wrappedFun = function () {
+    let args = [];
+    for (let i = 0, l = arguments.length; i < l; i++)
+      args.push(wrap(arguments[i]));
+    
+    //console.log("Called from native :"+obj+"."+name);
+    //console.log(">args "+arguments.length);
+    //console.log(fun);
+    
+    // Native code can execute this callback with `this` being the wrapped 
+    // function. For example, window.mozRequestAnimationFrame.
+    if (this == wrappedFun)
+      return fun.apply(fun, args);
+    
+    return fun.apply(wrap(this), args);
+  };
+  
+  Object.defineProperty(fun, "___proxy", {value : wrappedFun,
+                                          writable : false,
+                                          enumerable : false,
+                                          configurable : false});
+  
+  return wrappedFun;
+}
+
+/**
+ * Returns a closure that unwraps arguments before calling the `fun` function,
+ * which can be used to build a wrapper for a native function that accepts
+ * wrapped arguments, since native function only accept unwrapped arguments.
+ *
+ * @param fun {Function}
+ *        the function to wrap
+ * @param originalObject {Object}
+ *        target object from which `fun` comes from
+ *        (optional, for debugging purpose)
+ * @param name {String}
+ *        name of the attribute from which `fun` is binded on `originalObject`
+ *        (optional, for debugging purpose)
+ *
+ * Example:
+ *   wrapper.appendChild = NativeFunctionWrapper(xray.appendChild, xray);
+ *   wrapper.appendChild(anotherWrapper);
+ * -> Allow to call xray.appendChild with unwrapped version of anotherWrapper
+ */
+function NativeFunctionWrapper(fun, originalObject, name) {
+  return function () {
+    let args = [];
+    let obj = this.valueOf ? this.valueOf(UNWRAP_ACCESS_KEY) : this;
+    
+    for (let i = 0, l = arguments.length; i < l; i++)
+      args.push( unwrap(arguments[i], obj, name) );
+    
+    //if (name != "toString")
+    //console.log(">>calling native ["+(name?name:'#closure#')+"]: \n"+fun.apply+"\n"+obj+"\n("+args.join(', ')+")\nthis :"+obj+"from:"+originalObject+"\n");
+    
+    // Need to use Function.prototype.apply.apply because XMLHttpRequest 
+    // is a function (typeof return 'function') and fun.apply is null :/
+    let unwrapResult = Function.prototype.apply.apply(fun, [obj, args]);
+    let result = wrap(unwrapResult, obj, name);
+    
+    //console.log("<< "+rr+" -> "+r);
+    
+    return result;
+  };
+}
+
+/*
+ * Unwrap a JS value that comes from the content script.
+ * Mainly converts proxy wrapper to XPCNativeWrapper.
+ */
+function unwrap(value, obj, name) {
+  //console.log("unwrap : "+value+" ("+name+")");
+  if (!value)
+    return value;
+  let type = typeof value;  
+  
+  // In case of proxy, unwrap them recursively 
+  // (it should not be recursive, just in case of)
+  if (["object", "function"].indexOf(type) !== -1 && 
+      "__isWrappedProxy" in value) {
+    while("__isWrappedProxy" in value)
+      value = value.valueOf(UNWRAP_ACCESS_KEY);
+    return value;
+  }
+  
+  // In case of functions we need to return a wrapper that converts native 
+  // arguments applied to this function into proxies.
+  if (type == "function")
+    return ContentScriptFunctionWrapper(value, obj, name);
+  
+  // We must wrap objects coming from content script too, as they may have
+  // a function that will be called by a native method.
+  // For example:
+  //   addEventListener(..., { handleEvent: function(event) {} }, ...);
+  if (type == "object")
+    return ContentScriptObjectWrapper(value);
+
+  if (["string", "number", "boolean"].indexOf(type) !== -1)
+    return value;
+  //console.log("return non-wrapped to native : "+typeof value+" -- "+value);
+  return value;
+}
+
+/**
+ * Returns a XrayWrapper proxy object that allow to wrap any of its function
+ * though `ContentScriptFunctionWrapper`. These proxies are given to
+ * XrayWrappers in order to automatically wrap values when they call a method
+ * of these proxies. So that they are only used internaly and content script,
+ * nor web page have ever access to them. As a conclusion, we can consider
+ * this code as being safe regarding web pages overload.
+ *
+ *
+ * @param obj {Object}
+ *        object coming from content script context to wrap
+ *
+ * Example:
+ *   let myListener = { handleEvent: function (event) {} };
+ *   node.addEventListener("click", myListener, false);
+ *   `event` has to be wrapped, so handleEvent has to be wrapped using
+ *   `ContentScriptFunctionWrapper` function.
+ *   In order to do so, we build this new kind of proxies.
+ */
+function ContentScriptObjectWrapper(obj) {
+  if ("___proxy" in obj && typeof obj.___proxy == "object")
+    return obj.___proxy;
+
+  function valueOf(key) {
+    if (key === UNWRAP_ACCESS_KEY)
+      return obj;
+    return this;
+  }
+
+  let proxy = Proxy.create({
+    // Fundamental traps
+    getPropertyDescriptor:  function(name) {
+      return Object.getOwnPropertyDescriptor(obj, name);
+    },
+    defineProperty: function(name, desc) {
+      return Object.defineProperty(obj, name, desc);
+    },
+    getOwnPropertyNames: function () {
+      return Object.getOwnPropertyNames(obj);
+    },
+    delete: function(name) {
+      return delete obj[name];
+    },
+    // derived traps
+    has: function(name) {
+      return name === "__isXrayWrapperProxy" ||
+             name in obj;
+    },
+    hasOwn: function(name) {
+      return Object.prototype.hasOwnProperty.call(obj, name);
+    },
+    get: function(receiver, name) {
+      if (name == "valueOf")
+        return valueOf;
+      let value = obj[name];
+      if (!value)
+        return value;
+
+      return unwrap(value);
+    },
+    set: function(receiver, name, val) {
+      obj[name] = val;
+      return true;
+    },
+    enumerate: function() {
+      var result = [];
+      for each (let name in obj) {
+        result.push(name);
+      };
+      return result;
+    },
+    keys: function() {
+      return Object.keys(obj);
+    }
+  });
+
+  Object.defineProperty(obj, "___proxy", {value : proxy,
+                                          writable : false,
+                                          enumerable : false,
+                                          configurable : false});
+
+  return proxy;
+}
+
+/*
+ * Wrap a JS value coming from the document by building a proxy wrapper.
+ */
+function wrap(value, obj, name, debug) {
+  if (!value)
+    return value;
+  let type = typeof value;
+  if (type == "object") {
+    // We may have a XrayWrapper proxy.
+    // For example:
+    //   let myListener = { handleEvent: function () {} };
+    //   node.addEventListener("click", myListener, false);
+    // When native code want to call handleEvent,
+    // we go though ContentScriptFunctionWrapper that calls `wrap(this)`
+    // `this` is the XrayWrapper proxy of myListener.
+    // We return this object without building a CS proxy as it is already
+    // a value coming from the CS.
+    if ("__isXrayWrapperProxy" in value)
+      return value.valueOf(UNWRAP_ACCESS_KEY);
+
+    // Unwrap object before wrapping it.
+    // It should not happen with CS proxy objects.
+    while("__isWrappedProxy" in value) {
+      value = value.valueOf(UNWRAP_ACCESS_KEY);
+    }
+
+    if (XPCNativeWrapper.unwrap(value) !== value)
+      return getProxyForObject(value);
+    // In case of Event, HTMLCollection or NodeList or ???
+    // XPCNativeWrapper.unwrap(value) === value
+    // but it's still a XrayWrapper so let's build a proxy
+    return getProxyForObject(value);
+  }
+  if (type == "function") {
+    if (XPCNativeWrapper.unwrap(value) !== value
+        || (typeof value.toString === "function" && 
+            value.toString().match(/\[native code\]/))) {
+      return getProxyForFunction(value, NativeFunctionWrapper(value, obj, name));
+    }
+    return value;
+  }
+  if (type == "string")
+    return value;
+  if (type == "number")
+    return value;
+  if (type == "boolean")
+    return value;
+  //console.log("return non-wrapped to wrapped : "+value);
+  return value;
+}
+
+/* 
+ * Wrap an object from the document to a proxy wrapper
+ */
+function getProxyForObject(obj) {
+  if (typeof obj != "object") {
+    let msg = "tried to proxify something other than an object: " + typeof obj;
+    console.warn(msg);
+    throw msg;
+  }
+  if ("__isWrappedProxy" in obj) {
+    return obj;
+  }
+  // Check if there is a proxy cached on this wrapper,
+  // but take care of prototype ___proxy attribute inheritance!
+  if (obj && obj.___proxy && obj.___proxy.valueOf(UNWRAP_ACCESS_KEY) === obj) {
+    return obj.___proxy;
+  }
+  
+  let proxy = Proxy.create(handlerMaker(obj));
+  
+  Object.defineProperty(obj, "___proxy", {value : proxy,
+                                          writable : false,
+                                          enumerable : false,
+                                          configurable : false});
+  return proxy;
+}
+
+/* 
+ * Wrap a function from the document to a proxy wrapper
+ */
+function getProxyForFunction(fun, callTrap) {
+  if (typeof fun != "function") {
+    let msg = "tried to proxify something other than a function: " + typeof fun;
+    console.warn(msg);
+    throw msg;
+  }
+  if ("__isWrappedProxy" in fun)
+    return obj;
+  if ("___proxy" in fun)
+    return fun.___proxy;
+  
+  let proxy = Proxy.createFunction(handlerMaker(fun), callTrap);
+  
+  Object.defineProperty(fun, "___proxy", {value : proxy,
+                                          writable : false,
+                                          enumerable : false,
+                                          configurable : false});
+  
+  return proxy;
+}
+
+/* 
+ * Check if a DOM attribute name is an event name.
+ */
+function isEventName(id) {
+  if (id.indexOf("on") != 0 || id.length == 2) 
+    return false;
+  // Taken from:
+  // http://mxr.mozilla.org/mozilla-central/source/dom/base/nsDOMClassInfo.cpp#7616
+  switch (id[2]) {
+    case 'a' :
+      return (id == "onabort" ||
+              id == "onafterscriptexecute" ||
+              id == "onafterprint");
+    case 'b' :
+      return (id == "onbeforeunload" ||
+              id == "onbeforescriptexecute" ||
+              id == "onblur" ||
+              id == "onbeforeprint");
+    case 'c' :
+      return (id == "onchange"       ||
+              id == "onclick"        ||
+              id == "oncontextmenu"  ||
+              id == "oncopy"         ||
+              id == "oncut"          ||
+              id == "oncanplay"      ||
+              id == "oncanplaythrough");
+    case 'd' :
+      return (id == "ondblclick"     || 
+              id == "ondrag"         ||
+              id == "ondragend"      ||
+              id == "ondragenter"    ||
+              id == "ondragleave"    ||
+              id == "ondragover"     ||
+              id == "ondragstart"    ||
+              id == "ondrop"         ||
+              id == "ondurationchange");
+    case 'e' :
+      return (id == "onerror" ||
+              id == "onemptied" ||
+              id == "onended");
+    case 'f' :
+      return id == "onfocus";
+    case 'h' :
+      return id == "onhashchange";
+    case 'i' :
+      return (id == "oninput" ||
+              id == "oninvalid");
+    case 'k' :
+      return (id == "onkeydown"      ||
+              id == "onkeypress"     ||
+              id == "onkeyup");
+    case 'l' :
+      return (id == "onload"           ||
+              id == "onloadeddata"     ||
+              id == "onloadedmetadata" ||
+              id == "onloadstart");
+    case 'm' :
+      return (id == "onmousemove"    ||
+              id == "onmouseout"     ||
+              id == "onmouseover"    ||
+              id == "onmouseup"      ||
+              id == "onmousedown"    ||
+              id == "onmessage");
+    case 'p' :
+      return (id == "onpaint"        ||
+              id == "onpageshow"     ||
+              id == "onpagehide"     ||
+              id == "onpaste"        ||
+              id == "onpopstate"     ||
+              id == "onpause"        ||
+              id == "onplay"         ||
+              id == "onplaying"      ||
+              id == "onprogress");
+    case 'r' :
+      return (id == "onreadystatechange" ||
+              id == "onreset"            ||
+              id == "onresize"           ||
+              id == "onratechange");
+    case 's' :
+      return (id == "onscroll"       ||
+              id == "onselect"       ||
+              id == "onsubmit"       || 
+              id == "onseeked"       ||
+              id == "onseeking"      ||
+              id == "onstalled"      ||
+              id == "onsuspend");
+    case 't':
+      return id == "ontimeupdate" 
+      /* 
+        // TODO: Make it work for mobile version
+        ||
+        (nsDOMTouchEvent::PrefEnabled() &&
+         (id == "ontouchstart" ||
+          id == "ontouchend" ||
+          id == "ontouchmove" ||
+          id == "ontouchenter" ||
+          id == "ontouchleave" ||
+          id == "ontouchcancel"))*/;
+      
+    case 'u' :
+      return id == "onunload";
+    case 'v':
+      return id == "onvolumechange";
+    case 'w':
+      return id == "onwaiting";
+    }
+  
+  return false;
+}
+
+// XrayWrappers miss some attributes.
+// Here is a list of functions that return a value when it detects a miss:
+const NODES_INDEXED_BY_NAME = ["IMG", "FORM", "APPLET", "EMBED", "OBJECT"];
+const xRayWrappersMissFixes = [
+  
+  // Fix bug with XPCNativeWrapper on HTMLCollection
+  // We can only access array item once, then it's undefined :o
+  function (obj, name) {
+    let i = parseInt(name);
+    if (obj.toString().match(/HTMLCollection|NodeList/) && 
+        i >= 0 && i < obj.length) {
+      return wrap(XPCNativeWrapper(obj.wrappedJSObject[name]), obj, name);
+    }
+    return null;
+  },
+  
+  // Trap access to document["form name"] 
+  // that may refer to an existing form node
+  // http://mxr.mozilla.org/mozilla-central/source/dom/base/nsDOMClassInfo.cpp#9285
+  function (obj, name) {
+    if ("nodeType" in obj && obj.nodeType == 9) {
+      let node = obj.wrappedJSObject[name];
+      // List of supported tag:
+      // http://mxr.mozilla.org/mozilla-central/source/content/html/content/src/nsGenericHTMLElement.cpp#1267
+      if (node && NODES_INDEXED_BY_NAME.indexOf(node.tagName) != -1)
+        return wrap(XPCNativeWrapper(node));
+    }
+    return null;
+  },
+  
+  // Trap access to window["frame name"] and window.frames[i]
+  // that refer to an (i)frame internal window object
+  // http://mxr.mozilla.org/mozilla-central/source/dom/base/nsDOMClassInfo.cpp#6824
+  function (obj, name) {
+    if (typeof obj == "object" && "document" in obj) {
+      // Ensure that we are on a window object
+      try {
+        obj.QueryInterface(Ci.nsIDOMWindow);
+      }
+      catch(e) {
+        return null;
+      }
+      // Integer case:
+      let i = parseInt(name);
+      if (i >= 0 && i in obj) {
+        return wrap(XPCNativeWrapper(obj[i]));
+      }
+      // String name case:
+      if (name in obj.wrappedJSObject) {
+        let win = obj.wrappedJSObject[name];
+        let nodes = obj.document.getElementsByName(name);
+        for (let i = 0, l = nodes.length; i < l; i++) {
+          let node = nodes[i];
+          if ("contentWindow" in node && 
+              node.contentWindow.wrappedJSObject == win)
+            return wrap(node.contentWindow);
+        }
+      }
+    }
+    return null;
+  },
+  
+  // Trap access to form["node name"]
+  // http://mxr.mozilla.org/mozilla-central/source/dom/base/nsDOMClassInfo.cpp#9477
+  function (obj, name) {
+    if (typeof obj == "object" && obj.tagName == "FORM") {
+      let match = obj.wrappedJSObject[name];
+      let nodes = obj.ownerDocument.getElementsByName(name);
+      for (let i = 0, l = nodes.length; i < l; i++) {
+        let node = nodes[i];
+        if (node.wrappedJSObject == match)
+          return wrap(node);
+      }
+    }
+  }
+
+];
+
+if (!xulApp.versionInRange(xulApp.platformVersion, "10.0a1", "*")) {
+  // Fix XPathResult's constants being undefined on XrayWrappers
+  // these constants are defined here:
+  // http://mxr.mozilla.org/mozilla-central/source/dom/interfaces/xpath/nsIDOMXPathResult.idl
+  // and are only numbers.
+  // The platform bug 665279 was fixed in Gecko 10.0a1.
+  // FIXME: remove this workaround once the SDK no longer supports Firefox 9.
+  xRayWrappersMissFixes.push(
+    function (obj, name) {
+      if (typeof obj == "object" && name in Ci.nsIDOMXPathResult) {
+        let value = Ci.nsIDOMXPathResult[name];
+        if (typeof value == "number" && value === obj.wrappedJSObject[name])
+          return value;
+      }
+    }
+  );
+}
+
+// XrayWrappers have some buggy methods.
+// Here is the list of them with functions returning some replacement 
+// for a given object `obj`:
+const xRayWrappersMethodsFixes = {
+  // postMessage method is checking the Javascript global
+  // and it expects it to be a window object.
+  // But in our case, the global object is our sandbox global object.
+  // See nsGlobalWindow::CallerInnerWindow():
+  // http://mxr.mozilla.org/mozilla-central/source/dom/base/nsGlobalWindow.cpp#5893
+  // nsCOMPtr<nsPIDOMWindow> win = do_QueryWrappedNative(wrapper);
+  //   win is null
+  postMessage: function (obj) {
+    // Ensure that we are on a window object
+    try {
+      obj.QueryInterface(Ci.nsIDOMWindow);
+    }
+    catch(e) {
+      return null;
+    }
+    // Create a wrapper that is going to call `postMessage` through `eval`
+    let f = function postMessage(message, targetOrigin) {
+      message = message.toString().replace(/'/g,"\\'");
+      targetOrigin = targetOrigin.toString().replace(/'/g,"\\'");
+      let jscode = "this.postMessage('" + message + "', '" +
+                                targetOrigin + "')";
+      return this.wrappedJSObject.eval(jscode);
+    };
+    return getProxyForFunction(f, NativeFunctionWrapper(f));
+  },
+  
+  // Fix mozMatchesSelector uses that is broken on XrayWrappers
+  // when we use document.documentElement.mozMatchesSelector.call(node, expr)
+  // It's only working if we call mozMatchesSelector on the node itself.
+  // SEE BUG 658909: mozMatchesSelector returns incorrect results with XrayWrappers
+  mozMatchesSelector: function (obj) {
+    // Ensure that we are on an object to expose this buggy method
+    try {
+      obj.QueryInterface(Ci.nsIDOMNSElement);
+    }
+    catch(e) {
+      return null;
+    }
+    // We can't use `wrap` function as `f` is not a native function,
+    // so wrap it manually:
+    let f = function mozMatchesSelector(selectors) {
+      return this.mozMatchesSelector(selectors);
+    };
+
+    return getProxyForFunction(f, NativeFunctionWrapper(f));
+  },
+
+  // Bug 679054: History API doesn't work with Proxy objects.
+  // We have to pass regular JS objects on `pushState` and replaceState methods.
+  pushState: function (obj) {
+    // Ensure that we are on an object that expose History API
+    try {
+      obj.QueryInterface(Ci.nsIDOMHistory);
+    }
+    catch(e) {
+      return null;
+    }
+    let f = function fix() {
+      // Call native method with JSON objects
+      // (need to convert `arguments` to an array via `slice`)
+      return this.pushState.apply(this, JSON.parse(JSON.stringify(Array.slice(arguments))));
+    };
+
+    return getProxyForFunction(f, NativeFunctionWrapper(f));
+  },
+  replaceState: function (obj) {
+    // Ensure that we are on an object that expose History API
+    try {
+      obj.QueryInterface(Ci.nsIDOMHistory);
+    }
+    catch(e) {
+      return null;
+    }
+    let f = function fix() {
+      // Call native method with JSON objects
+      // (need to convert `arguments` to an array via `slice`)
+      return this.replaceState.apply(this, JSON.parse(JSON.stringify(Array.slice(arguments))));
+    };
+
+    return getProxyForFunction(f, NativeFunctionWrapper(f));
+  }
+};
+
+/* 
+ * Generate handler for proxy wrapper
+ */
+function handlerMaker(obj) {
+  // Overloaded attributes dictionary
+  let overload = {};
+  // Expando attributes dictionary (i.e. onclick, onfocus, on* ...)
+  let expando = {};
+  // Cache of methods overloaded to fix XrayWrapper bug
+  let methodFixes = {};
+  return {
+    // Fundamental traps
+    getPropertyDescriptor:  function(name) {
+      return Object.getOwnPropertyDescriptor(obj, name);
+    },
+    defineProperty: function(name, desc) {
+      return Object.defineProperty(obj, name, desc);
+    },
+    getOwnPropertyNames: function () {
+      return Object.getOwnPropertyNames(obj);
+    },
+    delete: function(name) {
+      delete expando[name];
+      delete overload[name];
+      return delete obj[name];
+    },
+    
+    // derived traps
+    has: function(name) {
+      if (name == "___proxy") return false;
+      if (isEventName(name)) {
+        // XrayWrappers throw exception when we try to access expando attributes
+        // even on "name in wrapper". So avoid doing it!
+        return name in expando;
+      }
+      return name in obj || name in overload || name == "__isWrappedProxy";
+    },
+    hasOwn: function(name) {
+      return Object.prototype.hasOwnProperty.call(obj, name);
+    },
+    get: function(receiver, name) {
+      
+      if (name == "___proxy")
+        return undefined;
+      
+      // Overload toString in order to avoid returning "[XrayWrapper [object HTMLElement]]"
+      // or "[object Function]" for function's Proxy
+      if (name == "toString")
+        return wrap(obj.wrappedJSObject ? obj.wrappedJSObject.toString
+                                        : obj.toString,
+                    obj, name);
+      
+      // Offer a way to retrieve XrayWrapper from a proxified node through `valueOf`
+      if (name == "valueOf")
+        return function (key) {
+          if (key === UNWRAP_ACCESS_KEY)
+            return obj;
+          return this;
+        };
+      
+      // Return overloaded value if there is one.
+      // It allows to overload native methods like addEventListener that
+      // are not saved, even on the wrapper itself.
+      // (And avoid some methods like toSource from being returned here! [__proto__ test])
+      if (name in overload &&
+          overload[name] != Object.getPrototypeOf(overload)[name] &&
+          name != "__proto__") {
+        return overload[name];
+      }
+      
+      // Catch exceptions thrown by XrayWrappers when we try to access on* 
+      // attributes like onclick, onfocus, ...
+      if (isEventName(name)) {
+        //console.log("expando:"+obj+" - "+obj.nodeType);
+        return name in expando ? expando[name].original : undefined;
+      }
+      
+      // Overload some XrayWrappers method in order to fix its bugs
+      if (name in methodFixes && 
+          methodFixes[name] != Object.getPrototypeOf(methodFixes)[name] &&
+          name != "__proto__")
+        return methodFixes[name];
+      if (Object.keys(xRayWrappersMethodsFixes).indexOf(name) !== -1) {
+        let fix = xRayWrappersMethodsFixes[name](obj);
+        if (fix)
+          return methodFixes[name] = fix;
+      }
+      
+      let o = obj[name];
+      
+      // XrayWrapper miss some attributes, try to catch these and return a value
+      if (!o) {
+        for each(let atttributeFixer in xRayWrappersMissFixes) {
+          let fix = atttributeFixer(obj, name);
+          if (fix)
+            return fix;
+        }
+      }
+
+      // Generic case
+      return wrap(o, obj, name);
+      
+    },
+    
+    set: function(receiver, name, val) {
+      
+      if (isEventName(name)) {
+        //console.log("SET on* attribute : " + name + " / " + val + "/" + obj);
+        let shortName = name.replace(/^on/,"");
+        
+        // Unregister previously set listener
+        if (expando[name]) {
+          obj.removeEventListener(shortName, expando[name], true);
+          delete expando[name];
+        }
+        
+        // Only accept functions
+        if (typeof val != "function")
+          return false;
+        
+        // Register a new listener
+        let original = val;
+        val = ContentScriptFunctionWrapper(val);
+        expando[name] = val;
+        val.original = original;
+        obj.addEventListener(name.replace(/^on/, ""), val, true);
+        return true;
+      }
+      
+      obj[name] = val;
+      
+      // Handle native method not overloaded on XrayWrappers:
+      //   obj.addEventListener = val; -> obj.addEventlistener = native method
+      // And, XPCNativeWrapper bug where nested values appear to be wrapped:
+      // obj.customNestedAttribute = val -> obj.customNestedAttribute !== val
+      //                                    obj.customNestedAttribute = "waive wrapper something"
+      // SEE BUG 658560: Fix identity problem with CrossOriginWrappers
+      // TODO: check that DOM can't be updated by the document itself and so overloaded value becomes wrong
+      //       but I think such behavior is limited to primitive type
+      if ((typeof val == "function" || typeof val == "object") && name) {
+        overload[name] = val;
+      }
+      
+      return true;
+    },
+    
+    enumerate: function() {
+      var result = [];
+      for each (name in Object.keys(obj)) {
+        result.push(name);
+      };
+      return result;
+    },
+    
+    keys: function() {
+      return Object.keys(obj);
+    }
+  };
+};
+
+
+/* 
+ * Wrap an object from the document to a proxy wrapper.
+ */
+exports.create = function create(object) {
+  // We accept either a XrayWrapper or an unwrapped reference
+  if ("wrappedJSObject" in object)
+    object = object.wrappedJSObject;
+
+  let xpcWrapper = XPCNativeWrapper(object);
+
+  // If we can't build an XPCNativeWrapper, it doesn't make sense to build
+  // a proxy. All proxy code is based on having such wrapper that store
+  // different JS attributes set.
+  // (we can't build XPCNativeWrapper when object is from the same
+  // principal/domain)
+  if (object === xpcWrapper) {
+    return object;
+  }
+  return getProxyForObject(xpcWrapper);
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/content/loader.js b/tools/addon-sdk-1.3/packages/api-utils/lib/content/loader.js
new file mode 100644
index 0000000..25bc651
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/content/loader.js
@@ -0,0 +1,203 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { EventEmitter } = require('../events');
+const { validateOptions, getTypeOf } = require('../api-utils');
+const { URL, toFilename } = require('../url');
+const file = require('../file');
+
+// map of property validations
+const valid = {
+  contentURL: {
+    ok: function (value) {
+      try {
+        URL(value);
+      }
+      catch(e) {
+        return false;
+      }
+      return true;
+    },
+    msg: 'The `contentURL` option must be a valid URL.'
+  },
+  contentScriptFile: {
+    is: ['undefined', 'null', 'string', 'array'],
+    map: function(value) 'undefined' === getTypeOf(value) ? null : value,
+    ok: function(value) {
+      if (getTypeOf(value) === 'array') {
+        // Make sure every item is a local file URL.
+        return value.every(function (item) {
+          try {
+            toFilename(item);
+            return true;
+          }
+          catch(e) {
+            return false;
+          }
+        });
+      }
+      return true;
+    },
+    msg: 'The `contentScriptFile` option must be a local file URL or an array of'
+          + 'URLs.'
+  },
+  contentScript: {
+    is: ['undefined', 'null', 'string', 'array'],
+    map: function(value) 'undefined' === getTypeOf(value) ? null : value,
+    ok: function(value) 'array' !== getTypeOf(value) ? true :
+      value.every(function(item) 'string' === getTypeOf(item))
+    ,
+    msg: 'The script option must be a string or an array of strings.'
+  },
+  contentScriptWhen: {
+    is: ['string'],
+    ok: function(value) ['start', 'ready', 'end'].indexOf(value) >= 0,
+    map: function(value) { 
+      return value || 'end';
+    },
+    msg: 'The `contentScriptWhen` option must be either "start", "ready" or "end".'
+  }
+};
+exports.validationAttributes = valid;
+
+/**
+ * Shortcut function to validate property with validation.
+ * @param {Object|Number|String} suspect
+ *    value to validate
+ * @param {Object} validation
+ *    validation rule passed to `api-utils`
+ */
+function validate(suspect, validation) validateOptions(
+  { $: suspect },
+  { $: validation }
+).$
+
+function Allow(script) ({
+  get script() script,
+  set script(value) script = !!value
+})
+
+/**
+ * Trait is intended to be used in some composition. It provides set of core
+ * properties and bounded validations to them. Trait is useful for all the
+ * compositions providing high level APIs for interaction with content.
+ * Property changes emit `"propertyChange"` events on instances.
+ */
+const Loader = EventEmitter.compose({
+  /**
+   * Permissions for the content, with the following keys:
+   * @property {Object} [allow = { script: true }]
+   * @property {Boolean} [allow.script = true]
+   *    Whether or not to execute script in the content.  Defaults to true.
+   */
+  get allow() this._allow || (this._allow = Allow(true)),
+  set allow(value) this.allow.script = value && value.script,
+  _allow: null,
+  /**
+   * The content to load. Either a string of HTML or a URL.
+   * @type {String}
+   */
+  get contentURL() this._contentURL,
+  set contentURL(value) {
+    value = validate(value, valid.contentURL);
+    if (this._contentURL != value) {
+      this._emit('propertyChange', {
+        contentURL: this._contentURL = value
+      });
+    }
+  },
+  _contentURL: null,
+  /**
+   * When to load the content scripts.
+   * Possible values are "end" (default), which loads them once all page 
+   * contents have been loaded, "ready", which loads them once DOM nodes are 
+   * ready (ie like DOMContentLoaded event), and "start", which loads them once 
+   * the `window` object for the page has been created, but before any scripts 
+   * specified by the page have been loaded.
+   * Property change emits `propertyChange` event on instance with this key
+   * and new value.
+   * @type {'start'|'ready'|'end'}
+   */
+  get contentScriptWhen() this._contentScriptWhen,
+  set contentScriptWhen(value) {
+    value = validate(value, valid.contentScriptWhen);
+    if (value !== this._contentScriptWhen) {
+      this._emit('propertyChange', { 
+        contentScriptWhen: this._contentScriptWhen = value 
+      });
+    }
+  },
+  _contentScriptWhen: 'end',
+  /**
+   * The URLs of content scripts.
+   * Property change emits `propertyChange` event on instance with this key
+   * and new value.
+   * @type {String[]}
+   */
+  get contentScriptFile() this._contentScriptFile,
+  set contentScriptFile(value) {
+    value = validate(value, valid.contentScriptFile);
+    if (value != this._contentScriptFile) {
+      this._emit('propertyChange', { 
+        contentScriptFile: this._contentScriptFile = value
+      });
+    }
+  },
+  _contentScriptFile: null,
+  /**
+   * The texts of content script.
+   * Property change emits `propertyChange` event on instance with this key
+   * and new value.
+   * @type {String|undefined}
+   */
+  get contentScript() this._contentScript,
+  set contentScript(value) {
+    value = validate(value, valid.contentScript);
+    if (value != this._contentScript) {
+      this._emit('propertyChange', {
+        contentScript: this._contentScript = value 
+      });
+    }
+  },
+  _contentScript: null
+});
+exports.Loader = Loader;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/content/symbiont.js b/tools/addon-sdk-1.3/packages/api-utils/lib/content/symbiont.js
new file mode 100644
index 0000000..25d80a1
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/content/symbiont.js
@@ -0,0 +1,201 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Myk Melez <myk@mozilla.org> (Original Author)
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { Worker } = require('./worker');
+const { Loader } = require('./loader');
+const hiddenFrames = require('../hidden-frame');
+const observers = require('../observer-service');
+const unload = require('../unload');
+
+/**
+ * This trait is layered on top of `Worker` and in contrast to symbiont
+ * Worker constructor requires `content` option that represents content
+ * that will be loaded in the provided frame, if frame is not provided
+ * Worker will create hidden one.
+ */
+const Symbiont = Worker.resolve({
+    constructor: '_initWorker',
+    destroy: '_workerDestroy'
+  }).compose(Loader, {
+  
+  /**
+   * The constructor requires all the options that are required by
+   * `require('content').Worker` with the difference that the `frame` option
+   * is optional. If `frame` is not provided, `contentURL` is expected.
+   * @param {Object} options
+   * @param {String} options.contentURL
+   *    URL of a content to load into `this._frame` and create worker for.
+   * @param {Element} [options.frame]
+   *    iframe element that is used to load `options.contentURL` into.
+   *    if frame is not provided hidden iframe will be created.
+   */
+  constructor: function Symbiont(options) {
+    options = options || {};
+
+    if ('contentURL' in options)
+        this.contentURL = options.contentURL;
+    if ('contentScriptWhen' in options)
+      this.contentScriptWhen = options.contentScriptWhen;
+    if ('contentScriptFile' in options)
+      this.contentScriptFile = options.contentScriptFile;
+    if ('contentScript' in options)
+      this.contentScript = options.contentScript;
+    if ('allow' in options)
+      this.allow = options.allow;
+    if ('onError' in options)
+        this.on('error', options.onError);
+    if ('onMessage' in options)
+        this.on('message', options.onMessage);
+    if ('frame' in options) {
+      this._initFrame(options.frame);
+    }
+    else {
+      let self = this;
+      this._hiddenFrame = hiddenFrames.HiddenFrame({
+        onReady: function onFrame() {
+          self._initFrame(this.element);
+        }
+      });
+      hiddenFrames.add(this._hiddenFrame);
+    }
+
+    unload.ensure(this._public, "destroy");
+  },
+  
+  destroy: function destroy() {
+    this._workerDestroy();
+    this._unregisterListener();
+    this._frame = null;
+    if (this._hiddenFrame) {
+      hiddenFrames.remove(this._hiddenFrame);
+      this._hiddenFrame = null;
+    }
+  },
+  
+  /**
+   * XUL iframe or browser elements with attribute `type` being `content`.
+   * Used to create `ContentSymbiont` from.
+   * @type {nsIFrame|nsIBrowser}
+   */
+  _frame: null,
+  
+  /**
+   * Listener to the `'frameReady"` event (emitted when `iframe` is ready).
+   * Removes listener, sets right permissions to the frame and loads content.
+   */
+  _initFrame: function _initFrame(frame) {
+    if (this._loadListener)
+      this._unregisterListener();
+    
+    this._frame = frame;
+    frame.docShell.allowJavascript = this.allow.script;
+    frame.setAttribute("src", this._contentURL);
+    
+    if ((frame.contentDocument.readyState == "complete" ||
+        (frame.contentDocument.readyState == "interactive" &&
+         this.contentScriptWhen != 'end' )) &&
+        frame.contentDocument.location == this._contentURL) {
+      // In some cases src doesn't change and document is already ready
+      // (for ex: when the user moves a widget while customizing toolbars.)
+      this._onInit();
+      return;
+    }
+    
+    let self = this;
+    
+    if ('start' == this.contentScriptWhen) {
+      this._loadEvent = 'start';
+      observers.add('document-element-inserted', 
+        this._loadListener = function onStart(doc) {
+          
+          let window = doc.defaultView;
+          if (window && window == frame.contentWindow) {
+            self._unregisterListener();
+            self._onInit();
+          }
+          
+        });
+      return;
+    }
+    
+    let eventName = 'end' == this.contentScriptWhen ? 'load' : 'DOMContentLoaded';
+    let self = this;
+    this._loadEvent = eventName;
+    frame.addEventListener(eventName, 
+      this._loadListener = function _onReady(event) {
+      
+        if (event.target != frame.contentDocument)
+          return;
+        self._unregisterListener();
+        
+        self._onInit();
+        
+      }, true);
+    
+  },
+  
+  /**
+   * Unregister listener that watchs for document being ready to be injected.
+   * This listener is registered in `Symbiont._initFrame`.
+   */
+  _unregisterListener: function _unregisterListener() {
+    if (!this._loadListener)
+      return;
+    if (this._loadEvent == "start") {
+      observers.remove('document-element-inserted', this._loadListener);
+    }
+    else {
+      this._frame.removeEventListener(this._loadEvent, this._loadListener,
+                                      true);
+    }
+    this._loadListener = null;
+  },
+  
+  /**
+   * Called by Symbiont itself when the frame is ready to load  
+   * content scripts according to contentScriptWhen. Overloaded by Panel. 
+   */
+  _onInit: function () {
+    this._initWorker({ window: this._frame.contentWindow });
+  }
+  
+});
+exports.Symbiont = Symbiont;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/content/worker.js b/tools/addon-sdk-1.3/packages/api-utils/lib/content/worker.js
new file mode 100644
index 0000000..e3126b6
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/content/worker.js
@@ -0,0 +1,597 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { shims } = require('../cuddlefish');
+const { Trait } = require('../traits');
+const { EventEmitter, EventEmitterTrait } = require('../events');
+const { Ci, Cu, Cc } = require('chrome');
+const timer = require('../timer');
+const { toFilename } = require('../url');
+const file = require('../file');
+const unload = require('../unload');
+const observers = require('../observer-service');
+const { Cortex } = require('../cortex');
+const { Enqueued } = require('../utils/function');
+const proxy = require('./content-proxy');
+
+const JS_VERSION = '1.8';
+
+const ERR_DESTROYED =
+  "The page has been destroyed and can no longer be used.";
+
+
+function ensureArgumentsAreJSON(args) {
+  // First convert to real array
+  let array = Array.prototype.slice.call(args);
+  // JSON.stringify is buggy with cross-sandbox values,
+  // it may return "{}" on functions. Use a replacer to match them correctly.
+  function replacer(k, v) {
+    return typeof v === "function" ? undefined : v;
+  }
+  return JSON.parse(JSON.stringify(array, replacer));
+}
+
+/**
+ * Extended `EventEmitter` allowing us to emit events asynchronously.
+ */
+const AsyncEventEmitter = EventEmitter.compose({
+  /**
+   * Emits event in the next turn of event loop.
+   */
+  _asyncEmit: function _asyncEmit() {
+    timer.setTimeout(function emitter(emit, scope, params) {
+      emit.apply(scope, params);
+    }, 0, this._emit, this, arguments)
+  }
+});
+
+/**
+ * Local trait providing implementation of the workers global scope.
+ * Used to configure global object in the sandbox.
+ * @see http://www.w3.org/TR/workers/#workerglobalscope
+ */
+const WorkerGlobalScope = AsyncEventEmitter.compose({
+  on: Trait.required,
+  _removeAllListeners: Trait.required,
+
+  // wrapped functions from `'timer'` module.
+  // Wrapper adds `try catch` blocks to the callbacks in order to
+  // emit `error` event on a symbiont if exception is thrown in
+  // the Worker global scope.
+  // @see http://www.w3.org/TR/workers/#workerutils
+
+  // List of all living timeouts/intervals
+  _timers: null,
+
+  setTimeout: function setTimeout(callback, delay) {
+    let params = Array.slice(arguments, 2);
+    let id = timer.setTimeout(function(self) {
+      try {
+        delete self._timers[id];
+        callback.apply(null, params);
+      } catch(e) {
+        self._addonWorker._asyncEmit('error', e);
+      }
+    }, delay, this);
+    this._timers[id] = true;
+    return id;
+  },
+  clearTimeout: function clearTimeout(id){
+    delete this._timers[id];
+    return timer.clearTimeout(id);
+  },
+
+  setInterval: function setInterval(callback, delay) {
+    let params = Array.slice(arguments, 2);
+    let id = timer.setInterval(function(self) {
+      try {
+        callback.apply(null, params); 
+      } catch(e) {
+        self._addonWorker._asyncEmit('error', e);
+      }
+    }, delay, this);
+    this._timers[id] = true;
+    return id;
+  },
+  clearInterval: function clearInterval(id) {
+    delete this._timers[id];
+    return timer.clearInterval(id);
+  },
+
+  /**
+   * `onMessage` function defined in the global scope of the worker context.
+   */
+  get _onMessage() this.__onMessage,
+  set _onMessage(value) {
+    let listener = this.__onMessage;
+    if (listener && value !== listener) {
+      this.removeListener('message', listener);
+      this.__onMessage = undefined;
+    }
+    if (value)
+      this.on('message', this.__onMessage = value);
+  },
+  __onMessage: undefined,
+
+  /**
+   * Function for sending data to the addon side.
+   * Validates that data is a `JSON` or primitive value and emits
+   * 'message' event on the worker in the next turn of the event loop.
+   * _Later this will be sending data across process boundaries._
+   * @param {JSON|String|Number|Boolean} data
+   */
+  postMessage: function postMessage(data) {
+    if (!this._addonWorker)
+      throw new Error(ERR_DESTROYED);
+    this._addonWorker._asyncEmit('message',  
+                                      JSON.parse(JSON.stringify(data)));
+  },
+  
+  /**
+   * EventEmitter, that behaves (calls listeners) asynchronously.
+   * A way to send customized messages to / from the worker.
+   * Events from in the worker can be observed / emitted via self.on / self.emit 
+   */
+  get port() this._port._public,
+  
+  /**
+   * Same object than this.port but private API.
+   * Allow access to _asyncEmit, in order to send event to port.
+   */
+  _port: null,
+
+  /**
+   * Alias to the global scope in the context of worker. Similar to
+   * `window` concept.
+   */
+  get self() this._public,
+
+  /**
+   * Configures sandbox and loads content scripts into it.
+   * @param {Worker} worker
+   *    content worker
+   */
+  constructor: function WorkerGlobalScope(worker) {
+    this._addonWorker = worker;
+    
+    // Hack in order to allow addon worker to access _asyncEmit
+    // as this is the private object of WorkerGlobalScope
+    worker._contentWorker = this;
+    
+    // create an event emitter that receive and send events from/to the addon
+    let contentWorker = this;
+    this._port = EventEmitterTrait.create({
+      emit: function () {
+        let addonWorker = contentWorker._addonWorker;
+        if (!addonWorker)
+          throw new Error(ERR_DESTROYED);
+        addonWorker._onContentScriptEvent.apply(addonWorker, arguments);
+      }
+    });
+    // create emit that executes in next turn of event loop.
+    this._port._asyncEmit = Enqueued(this._port._emit);
+    // expose wrapped port, that exposes only public properties. 
+    this._port._public = Cortex(this._port);
+    
+    // We receive an unwrapped window, with raw js access
+    let window = worker._window;
+    
+    // Create the sandbox and bind it to window in order for content scripts to
+    // have access to all standard globals (window, document, ...)
+    let sandbox = this._sandbox = new Cu.Sandbox(window, {
+      sandboxPrototype: proxy.create(window),
+      wantXrays: false
+    });
+    Object.defineProperties(sandbox, {
+      window: { get: function() sandbox },
+      top: { get: function() sandbox },
+      // Use the Greasemonkey naming convention to provide access to the
+      // unwrapped window object so the content script can access document
+      // JavaScript values.
+      // NOTE: this functionality is experimental and may change or go away
+      // at any time!
+      unsafeWindow: { get: function () window.wrappedJSObject }
+    });
+    
+    // Overriding / Injecting some natives into sandbox.
+    Cu.evalInSandbox(shims.contents, sandbox, JS_VERSION, shims.filename);
+    
+    // Initialize timer lists
+    this._timers = {};
+
+    let publicAPI = this._public;
+    
+    // List of content script globals:
+    let keys = ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 
+                'self'];
+    for each (let key in keys) {
+      Object.defineProperty(
+        sandbox, key, Object.getOwnPropertyDescriptor(publicAPI, key)
+      );
+    }
+    let self = this;
+    Object.defineProperties(sandbox, {
+      onMessage: {
+        get: function() self._onMessage,
+        set: function(value) {
+          console.warn("The global `onMessage` function in content scripts " +
+                       "is deprecated in favor of the `self.on()` function. " +
+                       "Replace `onMessage = function (data){}` definitions " +
+                       "with calls to `self.on('message', function (data){})`. " +
+                       "For more info on `self.on`, see " +
+                       "<https://addons.mozilla.org/en-US/developers/docs/sdk/latest/dev-guide/addon-development/web-content.html>.");
+          self._onMessage = value;
+        },
+        configurable: true
+      },
+      console: { value: console, configurable: true },
+      
+      // Deprecated use of on/postMessage from globals
+      on: {
+        value: function () {
+          console.warn("The global `on()` function in content scripts is " +
+                       "deprecated in favor of the `self.on()` function, " +
+                       "which works the same. Replace calls to `on()` with " +
+                       "calls to `self.on()`" +
+                       "For more info on `self.on`, see " +
+                       "<https://addons.mozilla.org/en-US/developers/docs/sdk/latest/dev-guide/addon-development/web-content.html>.");
+          publicAPI.on.apply(publicAPI, arguments);
+        },
+        configurable: true
+      }, 
+      postMessage: {
+        value: function () {
+          console.warn("The global `postMessage()` function in content " +
+                       "scripts is deprecated in favor of the " +
+                       "`self.postMessage()` function, which works the same. " +
+                       "Replace calls to `postMessage()` with calls to " +
+                       "`self.postMessage()`." +
+                       "For more info on `self.on`, see " +
+                       "<https://addons.mozilla.org/en-US/developers/docs/sdk/latest/dev-guide/addon-development/web-content.html>.");
+          publicAPI.postMessage.apply(publicAPI, arguments);
+        },
+        configurable: true
+      }
+    });
+
+    // The order of `contentScriptFile` and `contentScript` evaluation is
+    // intentional, so programs can load libraries like jQuery from script URLs
+    // and use them in scripts.
+    let contentScriptFile = ('contentScriptFile' in worker) ? worker.contentScriptFile
+          : null,
+        contentScript = ('contentScript' in worker) ? worker.contentScript : null;
+
+    if (contentScriptFile) {
+      if (Array.isArray(contentScriptFile))
+        this._importScripts.apply(this, contentScriptFile);
+      else
+        this._importScripts(contentScriptFile);
+    }
+    if (contentScript) {
+      this._evaluate(
+        Array.isArray(contentScript) ? contentScript.join(';\n') : contentScript
+      );
+    }
+  },
+  _destructor: function _destructor() {
+    this._removeAllListeners();
+    // Unregister all setTimeout/setInterval
+    // We can use `clearTimeout` for both setTimeout/setInterval
+    // as internal implementation of timer module use same method for both.
+    for (let id in this._timers)
+      timer.clearTimeout(id);
+    let publicAPI = this._public,
+        sandbox = this._sandbox;
+    delete sandbox.__proto__;
+    for (let key in publicAPI)
+      delete sandbox[key];
+    this._sandbox = null;
+    this._addonWorker = null;
+    this.__onMessage = undefined;
+  },
+  
+  /**
+   * JavaScript sandbox where all the content scripts are evaluated.
+   * {Sandbox}
+   */
+  _sandbox: null,
+  
+  /**
+   * Reference to the addon side of the worker.
+   * @type {Worker}
+   */
+  _addonWorker: null,
+  
+  /**
+   * Evaluates code in the sandbox.
+   * @param {String} code
+   *    JavaScript source to evaluate.
+   * @param {String} [filename='javascript:' + code]
+   *    Name of the file
+   */
+  _evaluate: function(code, filename) {
+    filename = filename || 'javascript:' + code;
+    try {
+      Cu.evalInSandbox(code, this._sandbox, JS_VERSION, filename, 1);
+    }
+    catch(e) {
+      this._addonWorker._asyncEmit('error', e);
+    }
+  },
+  /**
+   * Imports scripts to the sandbox by reading files under urls and
+   * evaluating its source. If exception occurs during evaluation
+   * `"error"` event is emitted on the worker.
+   * This is actually an analog to the `importScript` method in web
+   * workers but in our case it's not exposed even though content
+   * scripts may be able to do it synchronously since IO operation
+   * takes place in the UI process.
+   */
+  _importScripts: function _importScripts(url) {
+    let urls = Array.slice(arguments, 0);
+    for each (let contentScriptFile in urls) {
+      try {
+        let filename = toFilename(contentScriptFile);
+        this._evaluate(file.read(filename), filename);
+      }
+      catch(e) {
+        this._addonWorker._asyncEmit('error', e)
+      }
+    }
+  }
+});
+
+/**
+ * Message-passing facility for communication between code running
+ * in the content and add-on process.
+ * @see https://jetpack.mozillalabs.com/sdk/latest/docs/#module/api-utils/content/worker
+ */
+const Worker = AsyncEventEmitter.compose({
+  on: Trait.required,
+  _asyncEmit: Trait.required,
+  _removeAllListeners: Trait.required,
+  
+  /**
+   * Sends a message to the worker's global scope. Method takes single
+   * argument, which represents data to be sent to the worker. The data may
+   * be any primitive type value or `JSON`. Call of this method asynchronously
+   * emits `message` event with data value in the global scope of this
+   * symbiont.
+   *
+   * `message` event listeners can be set either by calling
+   * `self.on` with a first argument string `"message"` or by
+   * implementing `onMessage` function in the global scope of this worker.
+   * @param {Number|String|JSON} data
+   */
+  postMessage: function postMessage(data) {
+    if (!this._contentWorker)
+      throw new Error(ERR_DESTROYED);
+    this._contentWorker._asyncEmit('message',  JSON.parse(JSON.stringify(data)));
+  },
+  
+  /**
+   * EventEmitter, that behaves (calls listeners) asynchronously.
+   * A way to send customized messages to / from the worker.
+   * Events from in the worker can be observed / emitted via 
+   * worker.on / worker.emit.
+   */
+  get port() {
+    // We generate dynamically this attribute as it needs to be accessible
+    // before Worker.constructor gets called. (For ex: Panel)
+    
+    // create an event emitter that receive and send events from/to the worker
+    let self = this;
+    this._port = EventEmitterTrait.create({
+      emit: function () self._emitEventToContent(arguments)
+    });
+    // create emit that executes in next turn of event loop.
+    this._port._asyncEmit = Enqueued(this._port._emit);
+    // expose wrapped port, that exposes only public properties:
+    // We need to destroy this getter in order to be able to set the
+    // final value. We need to update only public port attribute as we never 
+    // try to access port attribute from private API.
+    delete this._public.port;
+    this._public.port = Cortex(this._port);
+    // Replicate public port to the private object
+    delete this.port;
+    this.port = this._public.port;
+    
+    return this._port;
+  },
+  
+  /**
+   * Same object than this.port but private API.
+   * Allow access to _asyncEmit, in order to send event to port.
+   */
+  _port: null,
+  
+  /**
+   * Emit a custom event to the content script, 
+   * i.e. emit this event on `self.port`
+   */
+  _emitEventToContent: function _emitEventToContent(args) {
+    // We need to save events that are emitted before the worker is 
+    // initialized
+    if (!this._inited) {
+      this._earlyEvents.push(args);
+      return;
+    }
+    
+    // We throw exception when the worker has been destroyed
+    if (!this._contentWorker) {
+      throw new Error(ERR_DESTROYED);
+    }
+    
+    let scope = this._contentWorker._port;
+    // Ensure that we pass only JSON values
+    scope._asyncEmit.apply(scope, ensureArgumentsAreJSON(args));
+  },
+  
+  // Is worker connected to the content worker (i.e. WorkerGlobalScope) ?
+  _inited: false,
+  
+  // List of custom events fired before worker is initialized
+  get _earlyEvents() {
+    delete this._earlyEvents;
+    this._earlyEvents = [];
+    return this._earlyEvents;
+  },
+  
+  constructor: function Worker(options) {
+    options = options || {};
+
+    if ('window' in options)
+      this._window = options.window;
+    if ('contentScriptFile' in options)
+      this.contentScriptFile = options.contentScriptFile;
+    if ('contentScript' in options)
+      this.contentScript = options.contentScript;
+    if ('onError' in options)
+      this.on('error', options.onError);
+    if ('onMessage' in options)
+      this.on('message', options.onMessage);
+    if ('onDetach' in options)
+      this.on('detach', options.onDetach);
+    
+    // Track document unload to destroy this worker.
+    // We can't watch for unload event on page's window object as it 
+    // prevents bfcache from working: 
+    // https://developer.mozilla.org/En/Working_with_BFCache
+    this._windowID = this._window.
+                     QueryInterface(Ci.nsIInterfaceRequestor).
+                     getInterface(Ci.nsIDOMWindowUtils).
+                     currentInnerWindowID;
+    observers.add("inner-window-destroyed", 
+                  this._documentUnload = this._documentUnload.bind(this));
+    
+    unload.ensure(this._public, "destroy");
+    
+    // Ensure that worker._port is initialized for contentWorker to be able
+    // to send use event during WorkerGlobalScope(this)
+    this.port;
+    
+    // will set this._contentWorker pointing to the private API:
+    WorkerGlobalScope(this);  
+    
+    // Mainly enable worker.port.emit to send event to the content worker
+    this._inited = true;
+    
+    // Flush all events that have been fired before the worker is initialized.
+    this._earlyEvents.forEach((function (args) this._emitEventToContent(args)).
+                              bind(this));
+  },
+  
+  _documentUnload: function _documentUnload(subject, topic, data) {
+    let innerWinID = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+    if (innerWinID != this._windowID) return false;
+    this._workerCleanup();
+    return true;
+  },
+
+  get url() {
+    // this._window will be null after detach
+    return this._window ? this._window.document.location.href : null;
+  },
+  
+  get tab() {
+    if (this._window) {
+      let tab = require("../tabs/tab");
+      // this._window will be null after detach
+      return tab.getTabForWindow(this._window);
+    }
+    return null;
+  },
+  
+  /**
+   * Tells content worker to unload itself and 
+   * removes all the references from itself.
+   */
+  destroy: function destroy() {
+    this._workerCleanup();
+    this._removeAllListeners('message');
+    this._removeAllListeners('error');
+    this._removeAllListeners('detach');
+  },
+  
+  /**
+   * Remove all internal references to the attached document
+   * Tells _port to unload itself and removes all the references from itself.
+   */
+  _workerCleanup: function _workerCleanup() {
+    // maybe unloaded before content side is created
+    // As Symbiont call worker.constructor on document load
+    if (this._contentWorker) 
+      this._contentWorker._destructor();
+    this._contentWorker = null;
+    this._window = null;
+    // This method may be called multiple times,
+    // avoid dispatching `detach` event more than once
+    if (this._windowID) {
+      this._windowID = null;
+      observers.remove("inner-window-destroyed", this._documentUnload);
+      this._earlyEvents.slice(0, this._earlyEvents.length);
+      this._emit("detach");
+    }
+  },
+  
+  /**
+   * Receive an event from the content script that need to be sent to 
+   * worker.port. Provide a way for composed object to catch all events.
+   */
+  _onContentScriptEvent: function _onContentScriptEvent() {
+    // Ensure that we pass only JSON values
+    this._port._asyncEmit.apply(this._port, ensureArgumentsAreJSON(arguments));
+  },
+  
+  /**
+   * Reference to the content side of the worker.
+   * @type {WorkerGlobalScope}
+   */
+  _contentWorker: null,
+
+  /**
+   * Reference to the window that is accessible from
+   * the content scripts.
+   * @type {Object}
+   */
+  _window: null,
+});
+exports.Worker = Worker;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/cortex.js b/tools/addon-sdk-1.3/packages/api-utils/lib/cortex.js
new file mode 100644
index 0000000..059d9de
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/cortex.js
@@ -0,0 +1,139 @@
+/* vim:set ts=2 sw=2 sts=2
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// `var` is being used in the module in order to make it reusable in
+// environments in which `let` and `const` is not yet supported.
+
+// Returns `object`'s property value, where `name` is a name of the property.
+function get(object, name) {
+  return object[name];
+}
+
+// Assigns `value` to the `object`'s property, where `name` is the name of the
+// property.
+function set(object, name, value) {
+  return object[name] = value;
+}
+
+/**
+ * Given an `object` containing a property with the given `name`, create
+ * a property descriptor that can be used to define alias/proxy properties
+ * on other objects.  A change in the value of an alias will propagate
+ * to the aliased property and vice versa.
+ */
+function createAliasProperty(object, name) {
+  // Getting own property descriptor of an `object` for the given `name` as
+  // we are going to create proxy analog.
+  var property = Object.getOwnPropertyDescriptor(object, name);
+  var descriptor = {
+    configurable: property.configurable,
+    enumerable: property.enumerable,
+    alias: true
+  };
+
+  // If the original property has a getter and/or setter, bind a
+  // corresponding getter/setter in the alias descriptor to the original
+  // object, so the `this` object in the getter/setter is the original object
+  // rather than the alias.
+  if ("get" in property && property.get)
+    descriptor.get = property.get.bind(object);
+  if ("set" in property && property.set)
+    descriptor.set = property.set.bind(object);
+  
+  // If original property was a value property.
+  if ("value" in property) {
+    // If original property is a method using it's `object` bounded copy.
+    if (typeof property.value === "function") {
+      descriptor.value = property.value.bind(object);
+      // Also preserving writability of the original property.
+      descriptor.writable = property.writable;
+    }
+
+    // If the original property was just a data property, we create proxy
+    // accessors using our custom get/set functions to propagate changes to the
+    // original `object` and vice versa.
+    else {
+      descriptor.get = get.bind(null, object, name);
+      descriptor.set = set.bind(null, object, name);
+    }
+  }
+  return descriptor;
+}
+
+// Defines property on `object` object with a name `alias` if given if not
+// defaults to `name` that represents an alias of `source[name]`. If aliased
+// property was an assessor or a method `this` pseudo-variable will be `source`
+// when invoked. If aliased property was a data property changes on any of the
+// aliases will propagate to the `source[name]` and also other way round.
+function defineAlias(source, target, name, alias) {
+  return Object.defineProperty(target, alias || name,
+                               createAliasProperty(source, name));
+}
+
+/**
+ * Function takes any `object` and returns a proxy for its own public
+ * properties. By default properties are considered to be public if they don't
+ * start with `"_"`, but default behavior can be overridden if needed, by
+ * passing array of public property `names` as a second argument. By default
+ * returned object will be direct decedent of the given `object`'s prototype,
+ * but this can be overridden by passing third optional argument, that will be
+ * used as `prototype` instead.
+ * @param {Object} object
+ *    Object to create cortex for.
+ * @param {String[]} [names]
+ *    Optional array of public property names.
+ * @param {Object} [prototype]
+ *    Optional argument that will be used as `prototype` of the returned object,
+ *    if not provided `Object.getPrototypeOf(object)` is used instead.
+ */
+exports.Cortex = function Cortex(object, names, prototype) {
+  // Creating a cortex object from the given `prototype`, if one was not
+  // provided then `prototype` of a given `object` is used. This allows
+  // consumer to define expected behavior `instanceof`. In common case
+  // `prototype` argument can be omitted to preserve same behavior of
+  // `instanceof` as on original `object`.
+  var cortex = Object.create(prototype || Object.getPrototypeOf(object));
+  // Creating alias properties on the `cortex` object for all the own
+  // properties of the original `object` that are contained in `names` array.
+  // If `names` array is not provided then all the properties that don't
+  // start with `"_"` are aliased.
+  Object.getOwnPropertyNames(object).forEach(function (name) {
+    if ((!names && "_" !== name.charAt(0)) || (names && ~names.indexOf(name)))
+      defineAlias(object, cortex, name);
+  });
+  return cortex;
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/cuddlefish.js b/tools/addon-sdk-1.3/packages/api-utils/lib/cuddlefish.js
new file mode 100644
index 0000000..70c71b5
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/cuddlefish.js
@@ -0,0 +1,182 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+(function(global) {
+
+   const Cc = Components.classes;
+   const Ci = Components.interfaces;
+   const Cu = Components.utils;
+   const Cr = Components.results;
+
+   var exports = {};
+
+   // Load the SecurableModule prerequisite.
+   var securableModule;
+   var myURI = Components.stack.filename.split(" -> ").slice(-1)[0];
+
+   if (global.require) {
+     // We're being loaded in a SecurableModule. This call also tells the
+     // manifest-scanner that it ought to scan securable-module.js
+     securableModule = require("api-utils/securable-module");
+   } else {
+     var ios = Cc['@mozilla.org/network/io-service;1']
+               .getService(Ci.nsIIOService);
+     var securableModuleURI = ios.newURI("securable-module.js", null,
+                                         ios.newURI(myURI, null, null));
+     if (securableModuleURI.scheme == "chrome") {
+       // The securable-module module is at a chrome URI, so we can't
+       // simply load it via Cu.import(). Let's assume we're in a
+       // chrome-privileged document and use mozIJSSubScriptLoader.
+       var loader = Cc["@mozilla.org/moz/jssubscript-loader;1"]
+                    .getService(Ci.mozIJSSubScriptLoader);
+
+       // Import the script, don't pollute the global scope.
+       securableModule = {__proto__: global};
+       loader.loadSubScript(securableModuleURI.spec, securableModule);
+       securableModule = securableModule.SecurableModule;
+     } else {
+       securableModule = {};
+       try {
+         Cu.import(securableModuleURI.spec, securableModule);
+       } catch (e if e.result == Cr.NS_ERROR_ILLEGAL_VALUE) {
+         Cu.reportError("Failed to load " + securableModuleURI.spec);
+       }
+     }
+   }
+
+   if (false) // force the manifest-scanner to copy shims.js into the XPI
+     require("api-utils/shims");
+   var localFS = new securableModule.LocalFileSystem(myURI);
+   var shimsPath = localFS.resolveModule(null, "shims");
+   var shims = exports.shims = localFS.getFile(shimsPath);
+
+   shims.filename = shimsPath;
+
+   function unloadLoader(reason, onError) {
+     this.require("api-utils/unload").send(reason, onError);
+   }
+
+   function makeGetModuleExports(delegate) {
+     return function getModuleExports(basePath, module) {
+       switch (module) {
+       case "chrome":
+         var chrome = { Cc: Components.classes,
+                        Ci: Components.interfaces,
+                        Cu: Components.utils,
+                        Cr: Components.results,
+                        Cm: Components.manager,
+                        components: Components };
+         return chrome;
+       default:
+         return (delegate ? delegate.call(this, basePath, module) : null);
+       }
+     };
+   }
+
+   function modifyModuleSandbox(sandbox, options) {
+     sandbox.evaluate(shims);
+     var filename = options.filename ? options.filename : null;
+     sandbox.defineProperty("__url__", filename);
+   }
+
+   var Loader = exports.Loader = function Loader(options) {
+     var globals = {};
+
+     if (options.globals)
+       for (let name in options.globals)
+         globals[name] = options.globals[name];
+
+     if (options.console)
+       globals.console = options.console;
+     if (options.memory)
+       globals.memory = options.memory;
+
+     if ('modules' in options)
+       throw new Error('options.modules is no longer supported');
+
+     var getModuleExports = makeGetModuleExports(options.getModuleExports);
+
+     var manifest = {};
+     if ("packaging" in options)
+       manifest = options.packaging.options.manifest;
+     var loaderOptions = {rootPath: options.rootPath,
+                          rootPaths: options.rootPaths,
+                          metadata: options.metadata,
+                          uriPrefix: options.uriPrefix,
+                          name: options.name,
+                          fs: options.fs,
+                          defaultPrincipal: "system",
+                          globals: globals,
+                          modifyModuleSandbox: modifyModuleSandbox,
+                          manifest: manifest,
+                          getModuleExports: getModuleExports};
+
+     var loader = new securableModule.Loader(loaderOptions);
+
+     if (!globals.console) {
+       var console = loader.require("api-utils/plain-text-console");
+       globals.console = new console.PlainTextConsole(options.print);
+     }
+     if (!globals.memory)
+       globals.memory = loader.require("api-utils/memory");
+
+     loader.console = globals.console;
+     loader.memory = globals.memory;
+     loader.unload = unloadLoader;
+
+     return loader;
+   };
+
+   if (global.window) {
+     // We're being loaded in a chrome window, or a web page with
+     // UniversalXPConnect privileges.
+     global.Cuddlefish = exports;
+   } else if (global.exports) {
+     // We're being loaded in a SecurableModule.
+     for (let name in exports) {
+       global.exports[name] = exports[name];
+     }
+   } else {
+     // We're being loaded in a JS module.
+     global.EXPORTED_SYMBOLS = [];
+     for (let name in exports) {
+       global.EXPORTED_SYMBOLS.push(name);
+       global[name] = exports[name];
+     }
+   }
+ })(this);
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/dom/events.js b/tools/addon-sdk-1.3/packages/api-utils/lib/dom/events.js
new file mode 100644
index 0000000..da9c93d
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/dom/events.js
@@ -0,0 +1,169 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// Utility function that returns copy of the given `text` with last character
+// removed if it is `"s"`.
+function singularify(text) {
+  return text[text.length - 1] === "s" ? text.substr(0, text.length - 1) : text;
+}
+
+// Utility function that takes event type, argument is passed to
+// `document.createEvent` and returns name of the initializer method of the
+// given event. Please note that there are some event types whose initializer
+// methods can't be guessed by this function. For more details see following
+// link: https://developer.mozilla.org/En/DOM/Document.createEvent
+function getInitializerName(category) {
+  return "init" + singularify(category);
+}
+
+/**
+ * Registers an event `listener` on a given `element`, that will be called
+ * when events of specified `type` is dispatched on the `element`.
+ * @param {Element} element
+ *    Dom element to register listener on.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type) to
+ *    listen for.
+ * @param {Function} listener
+ *    Function that is called whenever an event of the specified `type` 
+ *    occurs.
+ * @param {Boolean} capture
+ *    If true, indicates that the user wishes to initiate capture. After
+ *    initiating capture, all events of the specified type will be dispatched
+ *    to the registered listener before being dispatched to any `EventTarget`s
+ *    beneath it in the DOM tree. Events which are bubbling upward through
+ *    the tree will not trigger a listener designated to use capture.
+ *    See [DOM Level 3 Events](http://www.w3.org/TR/DOM-Level-3-Events/#event-flow)
+ *    for a detailed explanation.
+ */
+function on(element, type, listener, capture) {
+  // `capture` defaults to `false`.
+  capture = capture || false;
+  element.addEventListener(type, listener, capture);
+}
+exports.on = on;
+
+/**
+ * Registers an event `listener` on a given `element`, that will be called
+ * only once, next time event of specified `type` is dispatched on the
+ * `element`.
+ * @param {Element} element
+ *    Dom element to register listener on.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type) to
+ *    listen for.
+ * @param {Function} listener
+ *    Function that is called whenever an event of the specified `type` 
+ *    occurs.
+ * @param {Boolean} capture
+ *    If true, indicates that the user wishes to initiate capture. After
+ *    initiating capture, all events of the specified type will be dispatched
+ *    to the registered listener before being dispatched to any `EventTarget`s
+ *    beneath it in the DOM tree. Events which are bubbling upward through
+ *    the tree will not trigger a listener designated to use capture.
+ *    See [DOM Level 3 Events](http://www.w3.org/TR/DOM-Level-3-Events/#event-flow)
+ *    for a detailed explanation.
+ */
+function once(element, type, listener, capture) {
+  on(element, type, function selfRemovableListener(event) {
+    removeListener(element, type, selfRemovableListener, capture);
+    listener.apply(this, arguments);
+  }, capture);
+}
+exports.once = once;
+
+/**
+ * Unregisters an event `listener` on a given `element` for the events of the
+ * specified `type`.
+ *
+ * @param {Element} element
+ *    Dom element to unregister listener from.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type) to
+ *    listen for.
+ * @param {Function} listener
+ *    Function that is called whenever an event of the specified `type` 
+ *    occurs.
+ * @param {Boolean} capture
+ *    If true, indicates that the user wishes to initiate capture. After
+ *    initiating capture, all events of the specified type will be dispatched
+ *    to the registered listener before being dispatched to any `EventTarget`s
+ *    beneath it in the DOM tree. Events which are bubbling upward through
+ *    the tree will not trigger a listener designated to use capture.
+ *    See [DOM Level 3 Events](http://www.w3.org/TR/DOM-Level-3-Events/#event-flow)
+ *    for a detailed explanation.
+ */
+function removeListener(element, type, listener, capture) {
+  element.removeEventListener(type, listener, capture);
+}
+exports.removeListener = removeListener;
+
+/**
+ * Emits event of the specified `type` and `category` on the given `element`.
+ * Specified `settings` are used to initialize event before dispatching it.
+ * @param {Element} element
+ *    Dom element to dispatch event on.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type).
+ * @param {Object} options
+ *    Options object containing following properties:
+ *    - `category`: String passed to the `document.createEvent`. Option is
+ *      optional and defaults to "UIEvents".
+ *    - `initializer`: If passed it will be used as name of the method used
+ *      to initialize event. If omitted name will be generated from the
+ *      `category` field by prefixing it with `"init"` and removing last
+ *      character if it matches `"s"`.
+ *    - `settings`: Array of settings that are forwarded to the event
+ *      initializer after firs `type` argument.
+ * @see https://developer.mozilla.org/En/DOM/Document.createEvent
+ */
+function emit(element, type, { category, initializer, settings }) {
+  category = category || "UIEvents";
+  initializer = initializer || getInitializerName(category);
+  let document = element.ownerDocument;
+  let event = document.createEvent(category);
+  event[initializer].apply(event, [type].concat(settings));
+  element.dispatchEvent(event);
+};
+exports.emit = emit;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/dom/events/keys.js b/tools/addon-sdk-1.3/packages/api-utils/lib/dom/events/keys.js
new file mode 100644
index 0000000..155625a
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/dom/events/keys.js
@@ -0,0 +1,93 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { emit } = require("../events");
+const { getCodeForKey, toJSON } = require("../../keyboard/utils");
+const { has } = require("../../array");
+const { isString } = require("../../type");
+
+const INITIALIZER = "initKeyEvent";
+const CATEGORY = "KeyboardEvent";
+
+function Options(options) {
+  if (!isString(options))
+    return options;
+
+  var { key, modifiers } = toJSON(options);
+  return {
+    key: key,
+    control: has(modifiers, "control"),
+    alt: has(modifiers, "alt"),
+    shift: has(modifiers, "shift"),
+    meta: has(modifiers, "meta")
+  };
+}
+
+var keyEvent = exports.keyEvent = function keyEvent(element, type, options) {
+
+  emit(element, type, {
+    initializer: INITIALIZER,
+    category: CATEGORY,
+    settings: [
+      !("bubbles" in options) || options.bubbles !== false,
+      !("cancelable" in options) || options.cancelable !== false,
+      "window" in options && options.window ? options.window : null,
+      "control" in options && !!options.control,
+      "alt" in options && !!options.alt,
+      "shift" in options && !!options.shift,
+      "meta" in options && !!options.meta,
+      getCodeForKey(options.key) || 0,
+      options.key.length === 1 ? options.key.charCodeAt(0) : 0
+    ]
+  });
+}
+
+exports.keyDown = function keyDown(element, options) {
+  keyEvent(element, "keydown", Options(options));
+};
+
+exports.keyUp = function keyUp(element, options) {
+  keyEvent(element, "keyup", Options(options));
+};
+
+exports.keyPress = function keyPress(element, options) {
+  keyEvent(element, "keypress", Options(options));
+};
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/e10s.js b/tools/addon-sdk-1.3/packages/api-utils/lib/e10s.js
new file mode 100644
index 0000000..4a9acd8
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/e10s.js
@@ -0,0 +1,245 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+let {Cc, Ci, Cr} = require('chrome');
+
+let url = require("./url");
+let file = require("./file");
+let errors = require("./errors");
+
+let jetpackService = Cc["@mozilla.org/jetpack/service;1"]
+                     .getService(Ci.nsIJetpackService);
+
+function AddonProcess(jetpack) {
+  var syncListeners = {};
+
+  this.on = function(name, cb) {
+    jetpack.registerReceiver(name, function() {
+      try {
+        // Intentionally do not return the return value of
+        // the function; we want developers to use registerCall() for that.
+        cb.apply(undefined, arguments);
+      } catch (e) {
+        console.exception(e);
+      }
+    });
+  };
+
+  this.registerCall = function(name, cb) {
+    if (name in syncListeners)
+      throw new Error("call already registered for '" + name + "'");
+    syncListeners[name] = true;
+    jetpack.registerReceiver(name, errors.catchAndReturn(cb));
+  };
+
+  this.send = function() {
+    return jetpack.sendMessage.apply(this, arguments);
+  };
+  
+  this.createHandle = function() {
+    return jetpack.createHandle();
+  };
+
+  this.destroy = function() {
+    try {
+      jetpack.destroy();
+    } catch (e if e.result == Cr.NS_ERROR_NOT_INITIALIZED) {}
+  };
+}
+
+function makeScriptFrom(fs, moduleURL) {
+  // TODO: Why can't we just return fs.getFile(moduleURL) here?
+  return {
+    filename: moduleURL,
+    contents: fs.getFile(moduleURL).contents
+  };
+}
+
+var defaultConsole = console;
+
+exports.AddonProcess = function createAddonProcess(options) {
+  if (!options)
+    options = {};
+
+  var jetpack = jetpackService.createJetpack();  
+  var process = new AddonProcess(jetpack);
+  var registeredModules = {};
+
+  var console = options.console || defaultConsole;
+  var pkg = options.packaging || packaging;
+
+  // Whenever our add-on is disabled or uninstalled, we want to
+  // destroy the remote process.
+
+  require("./unload").when(function() {
+                           process.destroy();
+                           process = null;
+                         });
+
+  // Set up message receivers that the remote process will use to
+  // communicate with us.
+
+  ['log', 'debug', 'info', 'warn', 'error'].forEach(function(method) {
+    process.on("console:" + method, function(name, args) {
+      console[method].apply(console, args);
+    });
+  });
+
+  function remoteException(exception) {
+    return {
+      toString: function toString() {
+        return "Error: " + this.message;
+      },
+      __proto__: exception
+    };
+  }
+  
+  process.on("quit", function(name, status) {
+    if (options.quit)
+      options.quit(status);
+  });
+
+  process.on("console:trace", function(name, exception) {
+    var traceback = require("./traceback");
+    var stack = traceback.fromException(remoteException(exception));
+    console.log(traceback.format(stack.slice(0, -2)));
+  });
+
+  process.on("console:exception", function(name, exception) {
+    console.exception(remoteException(exception));
+  });
+  
+  jetpack.registerReceiver("dump", function(name, msg) {
+    dump(msg);
+  });
+
+  jetpack.registerReceiver(
+    "core:exception",
+    function(name, exception) {
+      console.log("An exception occurred in the child Jetpack process.");
+      console.exception(remoteException(exception));
+    });
+
+  process.registerCall(
+    "require",
+    function(name, base, path) {
+      var loader = options.loader;
+      var parentFS = loader.fs;
+      var moduleURL = parentFS.resolveModule(base, path);
+
+      if (!moduleURL)
+        return {code: "not-found"};
+
+      var moduleInfo = pkg.getModuleInfo(moduleURL);
+      var moduleName = path;
+
+      function maybeImportAdapterModule() {
+        var adapterModuleName = moduleName + "-e10s-adapter";
+        var adapterModuleURL = parentFS.resolveModule(base,
+                                                      adapterModuleName);
+        var adapterModuleInfo = null;
+        if (adapterModuleURL)
+          adapterModuleInfo = pkg.getModuleInfo(adapterModuleURL);
+
+        if (moduleInfo['e10s-adapter'] != adapterModuleURL) {
+          console.warn("Adapter module URL is " + adapterModuleURL +
+                       " but expected " + moduleInfo['e10s-adapter']);
+          return {code: "error"};
+        }
+
+        if (adapterModuleInfo) {
+          // e10s adapter found!
+          try {
+            if (!(adapterModuleURL in registeredModules)) {
+              // This e10s adapter has already been loaded for this
+              // addon process, and we only really need to give it the
+              // absolute URL of the adapter.
+              registeredModules[adapterModuleURL] = true;
+              loader.require(adapterModuleName).register(process);
+            }
+          } catch (e) {
+            console.exception(e);
+            return {code: "error"};
+          }
+          return {
+            code: "ok",
+            needsMessaging: true,
+            script: makeScriptFrom(parentFS, adapterModuleURL)
+          };
+        }
+        
+        return null;
+      }
+
+      if (moduleInfo) {
+        if (moduleInfo.needsChrome) {
+          return maybeImportAdapterModule() || {code: "access-denied"};
+        } else {
+
+          // Even if a module doesn't explicitly require chrome privileges, if
+          // an e10s adapter exists for it, use it, because said module might
+          // import other modules that require chrome.
+          //
+          // In the future we may want to look at the module's dependencies to
+          // determine whether importing an adapter is a better idea.
+
+          return maybeImportAdapterModule() || {
+            code: "ok",
+            needsMessaging: false,
+            script: makeScriptFrom(parentFS, moduleURL)
+          };
+        }
+      } else {
+        return maybeImportAdapterModule() || {code: "not-found"};
+      }
+    });
+
+  var bootURL = require("self").data.url("bootstrap-remote-process.js");
+  var bootFilename = url.toFilename(bootURL);
+  var bootJS = file.read(bootFilename);
+
+  // The try ... catch is a workaround for bug 589308.
+  jetpack.evalScript('//@line 1 "' + bootFilename + '"\n' +
+                     "try { " + bootJS + " } catch (e) { " +
+                     "sendMessage('core:exception', e); }");
+
+  process.send("addInjectedSandboxScript",
+               require("./cuddlefish").shimsCode);
+
+  return process;
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/errors.js b/tools/addon-sdk-1.3/packages/api-utils/lib/errors.js
new file mode 100644
index 0000000..56be526
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/errors.js
@@ -0,0 +1,92 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+function logToConsole(e) {
+  console.exception(e);
+}
+
+var catchAndLog = exports.catchAndLog = function(callback,
+                                                 defaultResponse,
+                                                 logException) {
+  if (!logException)
+    logException = logToConsole;
+
+  return function() {
+    try {
+      return callback.apply(this, arguments);
+    } catch (e) {
+      logException(e);
+      return defaultResponse;
+    }
+  };
+};
+
+exports.catchAndLogProps = function catchAndLogProps(object,
+                                                     props,
+                                                     defaultResponse,
+                                                     logException) {
+  if (typeof(props) == "string")
+    props = [props];
+  props.forEach(
+    function(property) {
+      object[property] = catchAndLog(object[property],
+                                     defaultResponse,
+                                     logException);
+    });
+};
+
+/**
+ * Catch and return an exception while calling the callback.  If the callback
+ * doesn't throw, return the return value of the callback in a way that makes it
+ * possible to distinguish between a return value and an exception.
+ *
+ * This function is useful when you need to pass the result of a call across
+ * a process boundary (across which exceptions don't propagate).  It probably
+ * doesn't need to be factored out into this module, since it is only used by
+ * a single caller, but putting it here works around bug 625560.
+ */
+exports.catchAndReturn = function(callback) {
+  return function() {
+    try {
+      return { returnValue: callback.apply(this, arguments) };
+    }
+    catch (exception) {
+      return { exception: exception };
+    }
+  };
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/events.js b/tools/addon-sdk-1.3/packages/api-utils/lib/events.js
new file mode 100644
index 0000000..4e36c00
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/events.js
@@ -0,0 +1,202 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *   Drew Willcoxon <adw@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const ERROR_TYPE = 'error',
+      UNCAUGHT_ERROR = 'An error event was dispatched for which there was'
+        + ' no listener.',
+      BAD_LISTENER = 'The event listener must be a function.';
+/**
+ * This object is used to create an `EventEmitter` that, useful for composing
+ * objects that emit events. It implements an interface like `EventTarget` from
+ * DOM Level 2, which is implemented by Node objects in implementations that
+ * support the DOM Event Model.
+ * @see http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget
+ * @see http://nodejs.org/api.html#EventEmitter
+ * @see http://livedocs.adobe.com/flash/9.0/ActionScriptLangRefV3/flash/events/EventDispatcher.html
+ */
+const eventEmitter =  {
+  /**
+   * Registers an event `listener` that is called every time events of
+   * specified `type` are emitted.
+   * @param {String} type
+   *    The type of event.
+   * @param {Function} listener
+   *    The listener function that processes the event.
+   * @example
+   *      worker.on('message', function (data) {
+   *          console.log('data received: ' + data)
+   *      })
+   */
+  on: function on(type, listener) {
+    if ('function' !== typeof listener)
+      throw new Error(BAD_LISTENER);
+    let listeners = this._listeners(type);
+    if (0 > listeners.indexOf(listener))
+      listeners.push(listener);
+    // Use of `_public` is required by the legacy traits code that will go away
+    // once bug-637633 is fixed.
+    return this._public || this;
+  },
+
+  /**
+   * Registers an event `listener` that is called once the next time an event
+   * of the specified `type` is emitted.
+   * @param {String} type
+   *    The type of the event.
+   * @param {Function} listener
+   *    The listener function that processes the event.
+   */
+  once: function once(type, listener) {
+    this.on(type, function selfRemovableListener() {
+      this.removeListener(type, selfRemovableListener);
+      listener.apply(this, arguments);
+    });
+  },
+
+  /**
+   * Unregister `listener` for the specified event type.
+   * @param {String} type
+   *    The type of event.
+   * @param {Function} listener
+   *    The listener function that processes the event.
+   */
+  removeListener: function removeListener(type, listener) {
+    if ('function' !== typeof listener)
+      throw new Error(BAD_LISTENER);
+    let listeners = this._listeners(type),
+        index = listeners.indexOf(listener);
+    if (0 <= index)
+      listeners.splice(index, 1);
+    // Use of `_public` is required by the legacy traits code, that will go away
+    // once bug-637633 is fixed.
+    return this._public || this;
+  },
+
+  /**
+   * Hash of listeners on this EventEmitter.
+   */
+  _events: null,
+
+  /**
+   * Returns an array of listeners for the specified event `type`. This array
+   * can be manipulated, e.g. to remove listeners.
+   * @param {String} type
+   *    The type of event.
+   */
+  _listeners: function listeners(type) {
+    let events = this._events || (this._events = {});
+    return events[type] || (events[type] = []);
+  },
+
+  /**
+   * Execute each of the listeners in order with the supplied arguments.
+   * Returns `true` if listener for this event was called, `false` if there are
+   * no listeners for this event `type`.
+   *
+   * All the exceptions that are thrown by listeners during the emit
+   * are caught and can be handled by listeners of 'error' event. Thrown
+   * exceptions are passed as an argument to an 'error' event listener.
+   * If no 'error' listener is registered exception will propagate to a
+   * caller of this method.
+   *
+   * **It's recommended to have a default 'error' listener in all the complete
+   * composition that in worst case may dump errors to the console.**
+   *
+   * @param {String} type
+   *    The type of event.
+   * @params {Object|Number|String|Boolean}
+   *    Arguments that will be passed to listeners.
+   * @returns {Boolean}
+   */
+  _emit: function _emit(type, event) {
+    let args = Array.slice(arguments);
+    // Use of `_public` is required by the legacy traits code that will go away
+    // once bug-637633 is fixed.
+    args.unshift(this._public || this);
+    return this._emitOnObject.apply(this, args);
+  },
+
+  /**
+   * A version of _emit that lets you specify the object on which listeners are
+   * called.  This is a hack that is sometimes necessary when such an object
+   * (exports, for example) cannot be an EventEmitter for some reason, but other
+   * object(s) managing events for the object are EventEmitters.  Once bug
+   * 577782 is fixed, this method shouldn't be necessary.
+   *
+   * @param {object} targetObj
+   *    The object on which listeners will be called.
+   * @param {string} type
+   *    The event name.
+   * @param {value} event
+   *    The first argument to pass to listeners.
+   * @param {value} ...
+   *    More arguments to pass to listeners.
+   * @returns {boolean}
+   */
+  _emitOnObject: function _emitOnObject(targetObj, type, event /* , ... */) {
+    let listeners = this._listeners(type).slice(0);
+    // If there is no 'error' event listener then throw.
+    if (type === ERROR_TYPE && !listeners.length)
+      console.exception(event);
+    if (!listeners.length)
+      return false;
+    let params = Array.slice(arguments, 2);
+    for each (let listener in listeners) {
+      try {
+        listener.apply(targetObj, params);
+      } catch(e) {
+        this._emit('error', e);
+      }
+    }
+    return true;
+  },
+
+  /**
+   * Removes all the event listeners for the specified event `type`.
+   * @param {String} type
+   *    The type of event.
+   */
+  _removeAllListeners: function _removeAllListeners(type) {
+    this._listeners(type).splice(0);
+    return this;
+  }
+};
+exports.EventEmitter = require("./traits").Trait.compose(eventEmitter);
+exports.EventEmitterTrait = require('./light-traits').Trait(eventEmitter);
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/events/assembler.js b/tools/addon-sdk-1.3/packages/api-utils/lib/events/assembler.js
new file mode 100644
index 0000000..26860d6
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/events/assembler.js
@@ -0,0 +1,86 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Trait } = require("../light-traits");
+const { removeListener, on } = require("../dom/events");
+
+/**
+ * Trait may be used for building objects / composing traits that wish to handle
+ * multiple dom events from multiple event targets in one place. Event targets
+ * can be added / removed by calling `observe / ignore` methods. Composer should
+ * provide array of event types it wishes to handle as property
+ * `supportedEventsTypes` and function for handling all those events as
+ * `handleEvent` property.
+ */
+exports.DOMEventAssembler = Trait({
+  /**
+   * Function that is supposed to handle all the supported events (that are
+   * present in the `supportedEventsTypes`) from all the observed
+   * `eventTargets`.
+   * @param {Event} event
+   *    Event being dispatched.
+   */
+  handleEvent: Trait.required,
+  /**
+   * Array of supported event names.
+   * @type {String[]}
+   */
+  supportedEventsTypes: Trait.required,
+  /**
+   * Adds `eventTarget` to the list of observed `eventTarget`s. Listeners for
+   * supported events will be registered on the given `eventTarget`.
+   * @param {EventTarget} eventTarget
+   */
+  observe: function observe(eventTarget) {
+    this.supportedEventsTypes.forEach(function(eventType) {
+      on(eventTarget, eventType, this);
+    }, this);
+  },
+  /**
+   * Removes `eventTarget` from the list of observed `eventTarget`s. Listeners
+   * for all supported events will be unregistered from the given `eventTarget`.
+   * @param {EventTarget} eventTarget
+   */
+  ignore: function ignore(eventTarget) {
+    this.supportedEventsTypes.forEach(function(eventType) {
+      removeListener(eventTarget, eventType, this);
+    }, this);
+  }
+});
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/file.js b/tools/addon-sdk-1.3/packages/api-utils/lib/file.js
new file mode 100644
index 0000000..30cb356
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/file.js
@@ -0,0 +1,227 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is nsINarwhal.
+ *
+ * The Initial Developer of the Original Code is
+ * Irakli Gozalishvili <rfobic@gmail.com>.
+ * Portions created by the Initial Developer are Copyright (C) 2009
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <rfobic@gmail.com>
+ *   Atul Varma <atul@mozilla.com>
+ *   Drew Willcoxon <adw@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci,Cr} = require("chrome");
+const byteStreams = require("./byte-streams");
+const textStreams = require("./text-streams");
+
+// Flags passed when opening a file.  See nsprpub/pr/include/prio.h.
+const OPEN_FLAGS = {
+  RDONLY: parseInt("0x01"),
+  WRONLY: parseInt("0x02"),
+  CREATE_FILE: parseInt("0x08"),
+  APPEND: parseInt("0x10"),
+  TRUNCATE: parseInt("0x20"),
+  EXCL: parseInt("0x80")
+};
+
+var dirsvc = Cc["@mozilla.org/file/directory_service;1"]
+             .getService(Ci.nsIProperties);
+
+function MozFile(path) {
+  var file = Cc['@mozilla.org/file/local;1']
+             .createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  return file;
+}
+
+function ensureReadable(file) {
+  if (!file.isReadable())
+    throw new Error("path is not readable: " + file.path);
+}
+
+function ensureDir(file) {
+  ensureExists(file);
+  if (!file.isDirectory())
+    throw new Error("path is not a directory: " + file.path);
+}
+
+function ensureFile(file) {
+  ensureExists(file);
+  if (!file.isFile())
+    throw new Error("path is not a file: " + file.path);
+}
+
+function ensureExists(file) {
+  if (!file.exists())
+    throw friendlyError(Cr.NS_ERROR_FILE_NOT_FOUND, file.path);
+}
+
+function friendlyError(errOrResult, filename) {
+  var isResult = typeof(errOrResult) === "number";
+  var result = isResult ? errOrResult : errOrResult.result;
+  switch (result) {
+  case Cr.NS_ERROR_FILE_NOT_FOUND:
+    return new Error("path does not exist: " + filename);
+  }
+  return isResult ? new Error("XPCOM error code: " + errOrResult) : errOrResult;
+}
+
+exports.exists = function exists(filename) {
+  return MozFile(filename).exists();
+};
+
+exports.isFile = function isFile(filename) {
+  return MozFile(filename).isFile();
+};
+
+exports.read = function read(filename, mode) {
+  if (typeof(mode) !== "string")
+    mode = "";
+
+  // Ensure mode is read-only.
+  mode = /b/.test(mode) ? "b" : "";
+
+  var stream = exports.open(filename, mode);
+  try {
+    var str = stream.read();
+  }
+  finally {
+    stream.close();
+  }
+
+  return str;
+};
+
+exports.join = function join(base) {
+  if (arguments.length < 2)
+    throw new Error("need at least 2 args");
+  base = MozFile(base);
+  for (var i = 1; i < arguments.length; i++)
+    base.append(arguments[i]);
+  return base.path;
+};
+
+exports.dirname = function dirname(path) {
+  var parent = MozFile(path).parent;
+  return parent ? parent.path : "";
+};
+
+exports.basename = function basename(path) {
+  var leafName = MozFile(path).leafName;
+
+  // On Windows, leafName when the path is a volume letter and colon ("c:") is
+  // the path itself.  But such a path has no basename, so we want the empty
+  // string.
+  return leafName == path ? "" : leafName;
+};
+
+exports.list = function list(path) {
+  var file = MozFile(path);
+  ensureDir(file);
+  ensureReadable(file);
+
+  var entries = file.directoryEntries;
+  var entryNames = [];
+  while(entries.hasMoreElements()) {
+    var entry = entries.getNext();
+    entry.QueryInterface(Ci.nsIFile);
+    entryNames.push(entry.leafName);
+  }
+  return entryNames;
+};
+
+exports.open = function open(filename, mode) {
+  var file = MozFile(filename);
+  if (typeof(mode) !== "string")
+    mode = "";
+
+  // File opened for write only.
+  if (/w/.test(mode)) {
+    if (file.exists())
+      ensureFile(file);
+    var stream = Cc['@mozilla.org/network/file-output-stream;1'].
+                 createInstance(Ci.nsIFileOutputStream);
+    var openFlags = OPEN_FLAGS.WRONLY |
+                    OPEN_FLAGS.CREATE_FILE |
+                    OPEN_FLAGS.TRUNCATE;
+    var permFlags = parseInt("0644"); // u+rw go+r
+    try {
+      stream.init(file, openFlags, permFlags, 0);
+    }
+    catch (err) {
+      throw friendlyError(err, filename);
+    }
+    return /b/.test(mode) ?
+           new byteStreams.ByteWriter(stream) :
+           new textStreams.TextWriter(stream);
+  }
+
+  // File opened for read only, the default.
+  ensureFile(file);
+  stream = Cc['@mozilla.org/network/file-input-stream;1'].
+           createInstance(Ci.nsIFileInputStream);
+  try {
+    stream.init(file, OPEN_FLAGS.RDONLY, 0, 0);
+  }
+  catch (err) {
+    throw friendlyError(err, filename);
+  }
+  return /b/.test(mode) ?
+         new byteStreams.ByteReader(stream) :
+         new textStreams.TextReader(stream);
+};
+
+exports.remove = function remove(path) {
+  var file = MozFile(path);
+  ensureFile(file);
+  file.remove(false);
+};
+
+exports.mkpath = function mkpath(path) {
+  var file = MozFile(path);
+  if (!file.exists())
+    file.create(Ci.nsIFile.DIRECTORY_TYPE, parseInt("0755")); // u+rwx go+rx
+  else if (!file.isDirectory())
+    throw new Error("The path already exists and is not a directory: " + path);
+};
+
+exports.rmdir = function rmdir(path) {
+  var file = MozFile(path);
+  ensureDir(file);
+  try {
+    file.remove(false);
+  }
+  catch (err) {
+    // Bug 566950 explains why we're not catching a specific exception here.
+    throw new Error("The directory is not empty: " + path);
+  }
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/find-tests-e10s-adapter.js b/tools/addon-sdk-1.3/packages/api-utils/lib/find-tests-e10s-adapter.js
new file mode 100644
index 0000000..fcd957b
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/find-tests-e10s-adapter.js
@@ -0,0 +1,112 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+if (this.chrome) {
+  var timer = require("./timer");
+  var ut = require("./unit-test");
+
+  chrome.on(
+    "runTest",
+    function(name, test) {
+      var runner = new ut.TestRunner();
+      runner.start({
+        test: test.testHandle,
+        onDone: function() {
+          test.passed = runner.test.passed;
+          test.failed = runner.test.failed;
+          test.errors = runner.test.errors;
+          chrome.send("testDone", test);
+        }
+      });
+    });
+    
+  exports.main = function(options, callbacks) {
+    function makeTest(suite, name, test) {
+      return function runTest(runner) {
+        console.info("executing '" + suite + "." + name + "' remotely");
+        test(runner);
+      };
+    }
+
+    var tests = [];
+
+    options.suites.forEach(function(suite) {
+      var module = require(suite);
+      for (testName in module) {
+        var handle = chrome.createHandle();
+        handle.testFunction = makeTest(suite, testName, module[testName]);
+        handle.name = suite + "." + testName;
+        tests.push({testHandle: handle, name: handle.name});
+      }
+    });
+    chrome.send("testsFound", tests, options.finderHandle);
+  }
+} else {
+  exports.register = function(addon) {
+    addon.on("testDone", function(name, remoteTest) {
+      var runner = remoteTest.testHandle.runner;
+      runner.passed += remoteTest.passed;
+      runner.failed += remoteTest.failed;
+      runner.test.passed = remoteTest.passed;
+      runner.test.failed = remoteTest.failed;
+      runner.test.errors = remoteTest.errors;
+      runner.done();
+    });
+    addon.on("testPass", function(name, remoteTest, msg) {
+      remoteTest.testHandle.runner.pass(msg);
+    });
+    addon.on("testFail", function(name, remoteTest, msg) {
+      remoteTest.testHandle.runner.fail(msg);
+    });
+    addon.on("testsFound", function(name, remoteTests,
+                                    finderHandle) {
+      var tests = [];
+      remoteTests.forEach(function(remoteTest) {
+        tests.push({
+          testFunction: function(runner) {
+            remoteTest.testHandle.runner = runner;
+            runner.waitUntilDone();
+            addon.send("runTest", remoteTest);
+          },
+          name: remoteTest.name
+        });
+      });
+      finderHandle.onTestsFound(tests);
+    });
+  };
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/find-tests.js b/tools/addon-sdk-1.3/packages/api-utils/lib/find-tests.js
new file mode 100644
index 0000000..be29d19
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/find-tests.js
@@ -0,0 +1 @@
+// this file left intentionally blank
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/hidden-frame.js b/tools/addon-sdk-1.3/packages/api-utils/lib/hidden-frame.js
new file mode 100644
index 0000000..241a4bc
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/hidden-frame.js
@@ -0,0 +1,200 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Felipe Gomes <felipc@gmail.com> (Original Author)
+ *   Myk Melez <myk@mozilla.org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc, Ci} = require("chrome");
+const errors = require("./errors");
+const apiUtils = require("./api-utils");
+const timer = require("./timer");
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+let hostFrame, hostDocument, hiddenWindow, isHostFrameReady = false;
+
+if (!require("./xul-app").isOneOf(["Firefox", "Thunderbird"])) {
+  throw new Error([
+    "The hidden-frame module currently supports only Firefox and Thunderbird. ",
+    "In the future, we would like it to support other applications, however. ",
+    "Please see https://bugzilla.mozilla.org/show_bug.cgi?id=546740 for more ",
+    "information."
+  ].join(""));
+}
+
+let appShellService = Cc["@mozilla.org/appshell/appShellService;1"].
+                        getService(Ci.nsIAppShellService);
+hiddenWindow = appShellService.hiddenDOMWindow;
+
+if (!hiddenWindow) {
+  throw new Error([
+    "The hidden-frame module needs an app that supports a hidden window. ",
+    "We would like it to support other applications, however. Please see ",
+    "https://bugzilla.mozilla.org/show_bug.cgi?id=546740 for more information."
+  ].join(""));
+}
+
+// Check if we can use the hidden window itself to host our iframes.
+// If it's not a suitable host, the hostFrame will be lazily created
+// by the first HiddenFrame instance.
+if (hiddenWindow.location.protocol == "chrome:" &&
+    (hiddenWindow.document.contentType == "application/vnd.mozilla.xul+xml" ||
+     hiddenWindow.document.contentType == "application/xhtml+xml")) {
+  hostFrame = hiddenWindow;
+  hostDocument = hiddenWindow.document;
+  isHostFrameReady = true;
+}
+
+function setHostFrameReady() {
+  hostDocument = hostFrame.contentDocument;
+  hostFrame.removeEventListener("DOMContentLoaded", setHostFrameReady, false);
+  isHostFrameReady = true;
+}
+
+// This cache is used to access friend properties between functions
+// without exposing them on the public API.
+let cache = [];
+
+exports.HiddenFrame = apiUtils.publicConstructor(HiddenFrame);
+
+function HiddenFrame(options) {
+  options = options || {};
+  let self = this;
+
+  for each (let [key, val] in Iterator(apiUtils.validateOptions(options, {
+    onReady: {
+      is: ["undefined", "function", "array"],
+      ok: function(v) {
+        if (apiUtils.getTypeOf(v) === "array") {
+          // make sure every item is a function
+          return v.every(function (item) typeof(item) === "function")
+        }
+        return true;
+      }
+    }
+  }))) {
+    if (typeof(val) != "undefined")
+      options[key] = val;
+  }
+
+  require("./collection").addCollectionProperty(this, "onReady");
+  if (options.onReady)
+    this.onReady.add(options.onReady);
+
+  if (!hostFrame) {
+    hostFrame = hiddenWindow.document.createElement("iframe");
+
+    // ugly ugly hack. This is the most lightweight chrome:// file I could find on the tree
+    // This hack should be removed by proper platform support on bug 565388 
+    hostFrame.setAttribute("src", "chrome://global/content/mozilla.xhtml");
+    hostFrame.addEventListener("DOMContentLoaded", setHostFrameReady, false);
+
+    hiddenWindow.document.body.appendChild(hostFrame);
+  }
+
+  this.toString = function toString() "[object Frame]";
+}
+
+exports.add = function JP_SDK_Frame_add(frame) {
+  if (!(frame instanceof HiddenFrame))
+    throw new Error("The object to be added must be a HiddenFrame.");
+
+  // This instance was already added.
+  if (cache.filter(function (v) v.frame === frame)[0])
+    return frame;
+
+  function createElement() {
+    hostFrame.removeEventListener("DOMContentLoaded", createElement, false);
+
+    let element = hostDocument.createElementNS(XUL_NS, "iframe");
+
+    element.setAttribute("type", "content");
+    hostDocument.documentElement.appendChild(element);
+
+    /* Public API: hiddenFrame.element */
+    frame.__defineGetter__("element", function () element);
+
+    // Notify consumers that the frame is ready.
+    function onReadyListener(event) {
+      element.removeEventListener("DOMContentLoaded", onReadyListener, false);
+      if (event.target == element.contentDocument) {
+        for (let handler in frame.onReady)
+          errors.catchAndLog(function () handler.call(frame))();
+      }
+    }
+    element.addEventListener("DOMContentLoaded", onReadyListener, false);
+
+    cache.push({
+      frame: frame,
+      element: element,
+      unload: function unload() {
+        hostDocument.documentElement.removeChild(element);
+      }
+    });
+  }
+
+  /* Begin element construction or schedule it for later */
+  if (isHostFrameReady) {
+    createElement();
+  } else {
+    hostFrame.addEventListener("DOMContentLoaded", createElement, false);
+  }
+
+  return frame;
+}
+
+exports.remove = function remove(frame) {
+  if (!(frame instanceof HiddenFrame))
+    throw new Error("The object to be removed must be a HiddenFrame.");
+
+  let entry = cache.filter(function (v) v.frame === frame)[0];
+  if (!entry)
+    return;
+
+  entry.unload();
+  cache.splice(cache.indexOf(entry), 1);
+}
+
+require("./unload").when(function () {
+  for each (let entry in cache.slice())
+    exports.remove(entry.frame);
+
+  if (hostFrame && hostFrame !== hiddenWindow)
+    hiddenWindow.document.body.removeChild(hostFrame);
+});
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/hotkeys.js b/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/hotkeys.js
new file mode 100644
index 0000000..6851671
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/hotkeys.js
@@ -0,0 +1,141 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *   Paul Vet <original.roju@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { observer: keyboardObserver } = require("./observer");
+const { getKeyForCode, normalize, isFunctionKey,
+        MODIFIERS } = require("./utils");
+
+/**
+ * Register a global `hotkey` that executes `listener` when the key combination
+ * in `hotkey` is pressed. If more then one `listener` is registered on the same
+ * key combination only last one will be executed.
+ *
+ * @param {string} hotkey
+ *    Key combination in the format of 'modifier key'.
+ *
+ * Examples:
+ *
+ *     "accel s"
+ *     "meta shift i"
+ *     "control alt d"
+ *
+ * Modifier keynames:
+ *
+ *  - **shift**: The Shift key.
+ *  - **alt**: The Alt key. On the Macintosh, this is the Option key. On
+ *    Macintosh this can only be used in conjunction with another modifier,
+ *    since `Alt+Letter` combinations are reserved for entering special
+ *    characters in text.
+ *  - **meta**: The Meta key. On the Macintosh, this is the Command key.
+ *  - **control**: The Control key.
+ *  - **accel**: The key used for keyboard shortcuts on the user's platform,
+ *    which is Control on Windows and Linux, and Command on Mac. Usually, this
+ *    would be the value you would use.
+ *
+ * @param {function} listener
+ *    Function to execute when the `hotkey` is executed.
+ */
+exports.register = function register(hotkey, listener) {
+  hotkey = normalize(hotkey);
+  hotkeys[hotkey] = listener;
+};
+
+/**
+ * Unregister a global `hotkey`. If passed `listener` is not the one registered
+ * for the given `hotkey`, the call to this function will be ignored.
+ *
+ * @param {string} hotkey
+ *    Key combination in the format of 'modifier key'.
+ * @param {function} listener
+ *    Function that will be invoked when the `hotkey` is pressed.
+ */
+exports.unregister = function unregister(hotkey, listener) {
+  hotkey = normalize(hotkey);
+  if (hotkeys[hotkey] === listener)
+    delete hotkeys[hotkey];
+};
+
+/**
+ * Map of hotkeys and associated functions.
+ */
+const hotkeys = exports.hotkeys = {};
+
+keyboardObserver.on("keydown", function onKeypress(event, window) {
+  let key, modifiers = [];
+  let isChar = "isChar" in event && event.isChar;
+  let which = "which" in event ? event.which : null;
+  let keyCode = "keyCode" in event ? event.keyCode : null;
+
+  if ("shiftKey" in event && event.shiftKey)
+    modifiers.push("shift");
+  if ("altKey" in event && event.altKey)
+    modifiers.push("alt");
+  if ("ctrlKey" in event && event.ctrlKey)
+    modifiers.push("control");
+  if ("metaKey" in event && event.metaKey)
+    modifiers.push("meta");
+
+  // If it's not a printable character then we fall back to a human readable
+  // equivalent of one of the following constants.
+  // http://mxr.mozilla.org/mozilla-central/source/dom/interfaces/events/nsIDOMKeyEvent.idl
+  key = getKeyForCode(keyCode);
+
+  // If only non-function (f1 - f24) key or only modifiers are pressed we don't
+  // have a valid combination so we return immediately (Also, sometimes
+  // `keyCode` may be one for the modifier which means we do not have a
+  // modifier).
+  if (!key || (!isFunctionKey(key) && !modifiers.length) || key in MODIFIERS)
+    return;
+
+  let combination = normalize({ key: key, modifiers: modifiers });
+  let hotkey = hotkeys[combination];
+
+  if (hotkey) {
+    try {
+      hotkey();
+    } catch (exception) {
+      console.exception(exception);
+    } finally {
+      // Work around bug 582052 by preventing the (nonexistent) default action.
+      event.preventDefault();
+    }
+  }
+});
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/observer.js b/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/observer.js
new file mode 100644
index 0000000..6968551
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/observer.js
@@ -0,0 +1,86 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Trait } = require("../light-traits");
+const { EventEmitterTrait: EventEmitter } = require("../events");
+const { DOMEventAssembler } = require("../events/assembler");
+const { browserWindowIterator, isBrowser } = require('../window-utils');
+const { observer: windowObserver } = require("../windows/observer");
+
+// Event emitter objects used to register listeners and emit events on them
+// when they occur.
+const observer = Trait.compose(DOMEventAssembler, EventEmitter).create({
+  /**
+   * Method is implemented by `EventEmitter` and is used just for emitting
+   * events on registered listeners.
+   */
+  _emit: Trait.required,
+  /**
+   * Events that are supported and emitted by the module.
+   */
+  supportedEventsTypes: [ "keydown", "keyup", "keypress" ],
+  /**
+   * Function handles all the supported events on all the windows that are
+   * observed. Method is used to proxy events to the listeners registered on
+   * this event emitter.
+   * @param {Event} event
+   *    Keyboard event being emitted.
+   */
+  handleEvent: function handleEvent(event) {
+    this._emit(event.type, event, event.target.ownerDocument.defaultView);
+  }
+});
+
+// Adding each opened window to a list of observed windows.
+windowObserver.on("open", function onOpen(window) {
+  if (isBrowser(window))
+    observer.observe(window);
+});
+// Removing each closed window form the list of observed windows.
+windowObserver.on("close", function onClose(window) {
+  if (isBrowser(window))
+    observer.ignore(window);
+});
+
+// Making observer aware of already opened windows.
+for each (let window in browserWindowIterator())
+  observer.observe(window);
+
+exports.observer = observer;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/utils.js b/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/utils.js
new file mode 100644
index 0000000..6e1ca74
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/keyboard/utils.js
@@ -0,0 +1,216 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *   Henri Wiechers <hwiechers@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Cc, Ci } = require("chrome");
+const runtime = require("../runtime");
+const { isString } = require("../type");
+const array = require("../array");
+
+
+const SWP = "{{SEPARATOR}}";
+const SEPARATOR = "-"
+const INVALID_COMBINATION = "Hotkey key combination must contain one or more " +
+                            "modifiers and only one key";
+
+// Map of modifier key mappings.
+const MODIFIERS = exports.MODIFIERS = {
+  'accel': runtime.OS === "Darwin" ? 'meta' : 'control',
+  'meta': 'meta',
+  'control': 'control',
+  'ctrl': 'control',
+  'option': 'alt',
+  'command': 'meta',
+  'alt': 'alt',
+  'shift': 'shift'
+};
+
+// Hash of key:code pairs for all the chars supported by `nsIDOMKeyEvent`.
+// This is just a copy of the `nsIDOMKeyEvent` hash with normalized names.
+// @See: http://mxr.mozilla.org/mozilla-central/source/dom/interfaces/events/nsIDOMKeyEvent.idl
+const CODES = exports.CODES = new function Codes() {
+  let nsIDOMKeyEvent = Ci.nsIDOMKeyEvent;
+  // Names that will be substituted with a shorter analogs.
+  let aliases = {
+    'subtract':     '-',
+    'add':          '+',
+    'equals':       '=',
+    'slash':        '/',
+    'backslash':    '\\',
+    'openbracket':  '[',
+    'closebracket': ']',
+    'quote':        '\'',
+    'backquote':    '`',
+    'period':       '.',
+    'semicolon':    ';',
+    'comma':        ','
+  };
+
+  // Normalizing keys and copying values to `this` object.
+  Object.keys(nsIDOMKeyEvent).filter(function(key) {
+    // Filter out only key codes.
+    return key.indexOf('DOM_VK') === 0;
+  }).map(function(key) {
+    // Map to key:values
+    return [ key, nsIDOMKeyEvent[key] ];
+  }).map(function([key, value]) {
+    return [ key.replace('DOM_VK_', '').replace('_', '').toLowerCase(), value ];
+  }).forEach(function ([ key, value ]) {
+    this[aliases[key] || key] = value;
+  }, this);
+};
+
+// Inverted `CODES` hash of `code:key`.
+const KEYS = exports.KEYS = new function Keys() {
+  Object.keys(CODES).forEach(function(key) {
+    this[CODES[key]] = key;
+  }, this)
+}
+
+exports.getKeyForCode = function getKeyForCode(code) { return KEYS[code]; };
+exports.getCodeForKey = function getCodeForKey(key) { return CODES[key]; };
+
+/**
+ * Utility function that takes string or JSON that defines a `hotkey` and
+ * returns normalized string version of it.
+ * @param {JSON|String} hotkey
+ * @param {String} [separator=" "]
+ *    Optional string that represents separator used to concatenate keys in the
+ *    given `hotkey`.
+ * @returns {String}
+ * @examples
+ *
+ *    require("keyboard/hotkeys").normalize("b Shift accel");
+ *    // 'control shift b' -> on windows & linux
+ *    // 'meta shift b'    -> on mac
+ *    require("keyboard/hotkeys").normalize("alt-d-shift", "-");
+ *    // 'alt shift d'
+ */
+var normalize = exports.normalize = function normalize(hotkey, separator) {
+  if (!isString(hotkey))
+    hotkey = toString(hotkey, separator);
+  return toString(toJSON(hotkey, separator), separator);
+};
+
+/*
+ * Utility function that splits a string of characters that defines a `hotkey`
+ * into modifier keys and the defining key.
+ * @param {String} hotkey
+ * @param {String} [separator=" "]
+ *    Optional string that represents separator used to concatenate keys in the
+ *    given `hotkey`.
+ * @returns {JSON}
+ * @examples
+ *
+ *    require("keyboard/hotkeys").toJSON("accel shift b");
+ *    // { key: 'b', modifiers: [ 'control', 'shift' ] } -> on windows & linux
+ *    // { key: 'b', modifiers: [ 'meta', 'shift' ] }    -> on mac
+ *
+ *    require("keyboard/hotkeys").normalize("alt-d-shift", "-");
+ *    // { key: 'd', modifiers: [ 'alt', 'shift' ] }
+ */
+var toJSON = exports.toJSON = function toJSON(hotkey, separator) {
+  separator = separator || SEPARATOR;
+  // Since default separator is `-`, combination may take form of `alt--`. To
+  // avoid misbehavior we replace `--` with `-{{SEPARATOR}}` where
+  // `{{SEPARATOR}}` can be swapped later.
+  hotkey = hotkey.toLowerCase().replace(separator + separator, separator + SWP);
+
+  let value = {};
+  let modifiers = [];
+  let keys = hotkey.split(separator);
+  keys.forEach(function(name) {
+    // If name is `SEPARATOR` than we swap it back.
+    if (name === SWP)
+      name = separator;
+    if (name in MODIFIERS) {
+      array.add(modifiers, MODIFIERS[name]);
+    } else {
+      if (!value.key)
+        value.key = name;
+      else
+        throw new TypeError(INVALID_COMBINATION);
+    }
+  });
+
+  if (!value.key)
+      throw new TypeError(INVALID_COMBINATION);
+
+  value.modifiers = modifiers.sort();
+  return value;
+};
+
+/**
+ * Utility function that takes object that defines a `hotkey` and returns
+ * string representation of it.
+ *
+ * _Please note that this function does not validates data neither it normalizes
+ * it, if you are unsure that data is well formed use `normalize` function
+ * instead.
+ *
+ * @param {JSON} hotkey
+ * @param {String} [separator=" "]
+ *    Optional string that represents separator used to concatenate keys in the
+ *    given `hotkey`.
+ * @returns {String}
+ * @examples
+ *
+ *    require("keyboard/hotkeys").toString({
+ *      key: 'b',
+ *      modifiers: [ 'control', 'shift' ]
+ *    }, '+');
+ *    // 'control+shift+b
+ *
+ */
+var toString = exports.toString = function toString(hotkey, separator) {
+  let keys = hotkey.modifiers.slice();
+  keys.push(hotkey.key);
+  return keys.join(separator || SEPARATOR);
+};
+
+/**
+ * Utility function takes `key` name and returns `true` if it's function key
+ * (F1, ..., F24) and `false` if it's not.
+ */
+var isFunctionKey = exports.isFunctionKey = function isFunctionKey(key) {
+  var $
+  return key[0].toLowerCase() === 'f' &&
+         ($ = parseInt(key.substr(1)), 0 < $ && $ < 25);
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/light-traits.js b/tools/addon-sdk-1.3/packages/api-utils/lib/light-traits.js
new file mode 100644
index 0000000..1afaad5
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/light-traits.js
@@ -0,0 +1,626 @@
+/* vim:ts=2:sts=2:sw=2:
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <rfobic@gmail.com> (Original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// `var` is being used in the module in order to make it reusable in
+// environments in which `let` is not yet supported.
+
+// Shortcut to `Object.prototype.hasOwnProperty.call`.
+// owns(object, name) would be the same as
+// Object.prototype.hasOwnProperty.call(object, name);
+var owns = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+
+/**
+ * Whether or not given property descriptors are equivalent. They are
+ * equivalent either if both are marked as 'conflict' or 'required' property
+ * or if all the properties of descriptors are equal.
+ * @param {Object} actual
+ * @param {Object} expected
+ */
+function equivalentDescriptors(actual, expected) {
+  return (actual.conflict && expected.conflict) ||
+         (actual.required && expected.required) ||
+         equalDescriptors(actual, expected);
+}
+/**
+ * Whether or not given property descriptors define equal properties.
+ */
+function equalDescriptors(actual, expected) {
+  return actual.get === expected.get &&
+         actual.set === expected.set &&
+         actual.value === expected.value &&
+         !!actual.enumerable === !!expected.enumerable &&
+         !!actual.configurable === !!expected.configurable &&
+         !!actual.writable === !!expected.writable;
+}
+
+// Utilities that throwing exceptions for a properties that are marked
+// as "required" or "conflict" properties.
+function throwConflictPropertyError(name) {
+  throw new Error("Remaining conflicting property: `" + name + "`");
+}
+function throwRequiredPropertyError(name) {
+  throw new Error("Missing required property: `" + name + "`");
+}
+
+/**
+ * Generates custom **required** property descriptor. Descriptor contains
+ * non-standard property `required` that is equal to `true`.
+ * @param {String} name
+ *    property name to generate descriptor for.
+ * @returns {Object}
+ *    custom property descriptor
+ */
+function RequiredPropertyDescriptor(name) {
+  // Creating function by binding first argument to a property `name` on the
+  // `throwConflictPropertyError` function. Created function is used as a
+  // getter & setter of the created property descriptor. This way we ensure
+  // that we throw exception late (on property access) if object with
+  // `required` property was instantiated using built-in `Object.create`.
+  var accessor = throwRequiredPropertyError.bind(null, name);
+  return { get: accessor, set: accessor, required: true };
+}
+
+/**
+ * Generates custom **conflicting** property descriptor. Descriptor contains
+ * non-standard property `conflict` that is equal to `true`.
+ * @param {String} name
+ *    property name to generate descriptor for.
+ * @returns {Object}
+ *    custom property descriptor
+ */
+function ConflictPropertyDescriptor(name) {
+  // For details see `RequiredPropertyDescriptor` since idea is same.
+  var accessor = throwConflictPropertyError.bind(null, name);
+  return { get: accessor, set: accessor, conflict: true };
+}
+
+/**
+ * Tests if property is marked as `required` property.
+ */
+function isRequiredProperty(object, name) {
+  return !!object[name].required;
+}
+
+/**
+ * Tests if property is marked as `conflict` property.
+ */
+function isConflictProperty(object, name) {
+  return !!object[name].conflict;
+}
+
+/**
+ * Function tests whether or not method of the `source` object with a given
+ * `name` is inherited from `Object.prototype`.
+ */
+function isBuiltInMethod(name, source) {
+  var target = Object.prototype[name];
+
+  // If methods are equal then we know it's `true`.
+  return target == source ||
+  // If `source` object comes form a different sandbox `==` will evaluate
+  // to `false`, in that case we check if functions names and sources match.
+         (String(target) === String(source) && target.name === source.name);
+}
+
+/**
+ * Function overrides `toString` and `constructor` methods of a given `target`
+ * object with a same-named methods of a given `source` if methods of `target`
+ * object are inherited / copied from `Object.prototype`.
+ * @see create
+ */
+function overrideBuiltInMethods(target, source) {
+  if (isBuiltInMethod("toString", target.toString)) {
+    Object.defineProperty(target, "toString",  {
+      value: source.toString,
+      configurable: true,
+      enumerable: false
+    });
+  }
+
+  if (isBuiltInMethod("constructor", target.constructor)) {
+    Object.defineProperty(target, "constructor", {
+      value: source.constructor,
+      configurable: true,
+      enumerable: false
+    });
+  }
+}
+
+/**
+ * Composes new trait with the same own properties as the original trait,
+ * except that all property names appearing in the first argument are replaced
+ * by "required" property descriptors.
+ * @param {String[]} keys
+ *    Array of strings property names.
+ * @param {Object} trait
+ *    A trait some properties of which should be excluded.
+ * @returns {Object}
+ * @example
+ *    var newTrait = exclude(["name", ...], trait)
+ */
+function exclude(names, trait) {
+  var map = {};
+
+  Object.keys(trait).forEach(function(name) {
+
+    // If property is not excluded (the array of names does not contain it),
+    // or it is a "required" property, copy it to the property descriptor `map`
+    // that will be used for creation of resulting trait.
+    if (!~names.indexOf(name) || isRequiredProperty(trait, name))
+      map[name] = { value: trait[name], enumerable: true };
+
+    // For all the `names` in the exclude name array we create required
+    // property descriptors and copy them to the `map`.
+    else
+      map[name] = { value: RequiredPropertyDescriptor(name), enumerable: true };
+  });
+
+  return Object.create(Trait.prototype, map);
+}
+
+/**
+ * Composes new instance of `Trait` with a properties of a given `trait`,
+ * except that all properties whose name is an own property of `renames` will
+ * be renamed to `renames[name]` and a `"required"` property for name will be
+ * added instead.
+ *
+ * For each renamed property, a required property is generated. If
+ * the `renames` map two properties to the same name, a conflict is generated.
+ * If the `renames` map a property to an existing unrenamed property, a
+ * conflict is generated.
+ *
+ * @param {Object} renames
+ *    An object whose own properties serve as a mapping from old names to new
+ *    names.
+ * @param {Object} trait
+ *    A new trait with renamed properties.
+ * @returns {Object}
+ * @example
+ *
+ *    // Return trait with `bar` property equal to `trait.foo` and with
+ *    // `foo` and `baz` "required" properties.
+ *    var renamedTrait = rename({ foo: "bar", baz: null }), trait);
+ *
+ *    // t1 and t2 are equivalent traits
+ *    var t1 = rename({a: "b"}, t);
+ *    var t2 = compose(exclude(["a"], t), { a: { required: true }, b: t[a] });
+ */
+function rename(renames, trait) {
+  var map = {};
+
+  // Loop over all the properties of the given `trait` and copy them to a
+  // property descriptor `map` that will be used for the creation of the
+  // resulting trait.  Also, rename properties in the `map` as specified by
+  // `renames`.
+  Object.keys(trait).forEach(function(name) {
+    var alias;
+
+    // If the property is in the `renames` map, and it isn't a "required"
+    // property (which should never need to be aliased because "required"
+    // properties never conflict), then we must try to rename it.
+    if (owns(renames, name) && !isRequiredProperty(trait, name)) {
+      alias = renames[name];
+
+      // If the `map` already has the `alias`, and it isn't a "required"
+      // property, that means the `alias` conflicts with an existing name for a
+      // provided trait (that can happen if >=2 properties are aliased to the
+      // same name). In this case we mark it as a conflicting property.
+      // Otherwise, everything is fine, and we copy property with an `alias`
+      // name.
+      if (owns(map, alias) && !map[alias].value.required) {
+        map[alias] = {
+          value: ConflictPropertyDescriptor(alias),
+          enumerable: true
+        };
+      }
+      else {
+        map[alias] = {
+          value: trait[name],
+          enumerable: true
+        };
+      }
+
+      // Regardless of whether or not the rename was successful, we check to
+      // see if the original `name` exists in the map (such a property
+      // could exist if previous another property was aliased to this `name`).
+      // If it isn't, we mark it as "required", to make sure the caller
+      // provides another value for the old name, which methods of the trait
+      // might continue to reference.
+      if (!owns(map, name)) {
+        map[name] = {
+          value: RequiredPropertyDescriptor(name),
+          enumerable: true
+        };
+      }
+    }
+
+    // Otherwise, either the property isn't in the `renames` map (thus the
+    // caller is not trying to rename it) or it is a "required" property.
+    // Either way, we don't have to alias the property, we just have to copy it
+    // to the map.
+    else {
+      // The property isn't in the map yet, so we copy it over.
+      if (!owns(map, name)) {
+        map[name] = { value: trait[name], enumerable: true };
+      }
+
+      // The property is already in the map (that means another property was
+      // aliased with this `name`, which creates a conflict if the property is
+      // not marked as "required"), so we have to mark it as a "conflict"
+      // property.
+      else if (!isRequiredProperty(trait, name)) {
+        map[name] = {
+          value: ConflictPropertyDescriptor(name),
+          enumerable: true
+        };
+      }
+    }
+  });
+  return Object.create(Trait.prototype, map);
+}
+
+/**
+ * Composes new resolved trait, with all the same properties as the original
+ * `trait`, except that all properties whose name is an own property of
+ * `resolutions` will be renamed to `resolutions[name]`.
+ *
+ * If `resolutions[name]` is `null`, the value is mapped to a property
+ * descriptor that is marked as a "required" property.
+ */
+function resolve(resolutions, trait) {
+    var renames = {};
+    var exclusions = [];
+
+    // Go through each mapping in `resolutions` object and distribute it either
+    // to `renames` or `exclusions`.
+    Object.keys(resolutions).forEach(function(name) {
+
+      // If `resolutions[name]` is a truthy value then it's a mapping old -> new
+      // so we copy it to `renames` map.
+      if (resolutions[name])
+        renames[name] = resolutions[name];
+
+      // Otherwise it's not a mapping but an exclusion instead in which case we
+      // add it to the `exclusions` array.
+      else
+        exclusions.push(name);
+    });
+
+    // First `exclude` **then** `rename` and order is important since
+    // `exclude` and `rename` are not associative.
+    return rename(renames, exclude(exclusions, trait));
+}
+
+/**
+ * Create a Trait (a custom property descriptor map) that represents the given
+ * `object`'s own properties. Property descriptor map is a "custom", because it
+ * inherits from `Trait.prototype` and it's property descriptors may contain
+ * two attributes that is not part of the ES5 specification:
+ *
+ *  - "required" (this property must be provided by another trait
+ *    before an instance of this trait can be created)
+ *  - "conflict" (when the trait is composed with another trait,
+ *    a unique value for this property is provided by two or more traits)
+ *
+ * Data properties bound to the `Trait.required` singleton exported by
+ * this module will be marked as "required" properties.
+ *
+ * @param {Object} object
+ *    Map of properties to compose trait from.
+ * @returns {Trait}
+ *    Trait / Property descriptor map containing all the own properties of the
+ *    given argument.
+ */
+function trait(object) {
+  var map;
+  var trait = object;
+
+  if (!(object instanceof Trait)) {
+    // If the passed `object` is not already an instance of `Trait`, we create
+    // a property descriptor `map` containing descriptors for the own properties
+    // of the given `object`.  `map` is then used to create a `Trait` instance
+    // after all properties are mapped.  Note that we can't create a trait and
+    // then just copy properties into it since that will fail for inherited
+    // read-only properties.
+    map = {};
+
+    // Each own property of the given `object` is mapped to a data property
+    // whose value is a property descriptor.
+    Object.keys(object).forEach(function (name) {
+
+      // If property of an `object` is equal to a `Trait.required`, it means
+      // that it was marked as "required" property, in which case we map it
+      // to "required" property.
+      if (Trait.required ==
+          Object.getOwnPropertyDescriptor(object, name).value) {
+        map[name] = {
+          value: RequiredPropertyDescriptor(name),
+          enumerable: true
+        };
+      }
+      // Otherwise property is mapped to it's property descriptor.
+      else {
+        map[name] = {
+          value: Object.getOwnPropertyDescriptor(object, name),
+          enumerable: true
+        };
+      }
+    });
+
+    trait = Object.create(Trait.prototype, map);
+  }
+  return trait;
+}
+
+/**
+ * Compose a property descriptor map that inherits from `Trait.prototype` and
+ * contains property descriptors for all the own properties of the passed
+ * traits.
+ *
+ * If two or more traits have own properties with the same name, the returned
+ * trait will contain a "conflict" property for that name. Composition is a
+ * commutative and associative operation, and the order of its arguments is
+ * irrelevant.
+ */
+function compose(trait1, trait2/*, ...*/) {
+  // Create a new property descriptor `map` to which all the own properties
+  // of the passed traits are copied.  This map will be used to create a `Trait`
+  // instance that will be the result of this composition.
+  var map = {};
+
+  // Properties of each passed trait are copied to the composition.
+  Array.prototype.forEach.call(arguments, function(trait) {
+    // Copying each property of the given trait.
+    Object.keys(trait).forEach(function(name) {
+
+      // If `map` already owns a property with the `name` and it is not
+      // marked "required".
+      if (owns(map, name) && !map[name].value.required) {
+
+        // If the source trait's property with the `name` is marked as
+        // "required", we do nothing, as the requirement was already resolved
+        // by a property in the `map` (because it already contains a
+        // non-required property with that `name`).  But if properties are just
+        // different, we have a name clash and we substitute it with a property
+        // that is marked "conflict".
+        if (!isRequiredProperty(trait, name) &&
+            !equivalentDescriptors(map[name].value, trait[name])
+        ) {
+          map[name] = {
+            value: ConflictPropertyDescriptor(name),
+            enumerable: true
+          };
+        }
+      }
+
+      // Otherwise, the `map` does not have an own property with the `name`, or
+      // it is marked "required".  Either way, the trait's property is copied to
+      // the map (if the property of the `map` is marked "required", it is going
+      // to be resolved by the property that is being copied).
+      else {
+        map[name] = { value: trait[name], enumerable: true };
+      }
+    });
+  });
+
+  return Object.create(Trait.prototype, map);
+}
+
+/**
+ *  `defineProperties` is like `Object.defineProperties`, except that it
+ *  ensures that:
+ *    - An exception is thrown if any property in a given `properties` map
+ *      is marked as "required" property and same named property is not
+ *      found in a given `prototype`.
+ *    - An exception is thrown if any property in a given `properties` map
+ *      is marked as "conflict" property.
+ * @param {Object} object
+ *    Object to define properties on.
+ * @param {Object} properties
+ *    Properties descriptor map.
+ * @returns {Object}
+ *    `object` that was passed as a first argument.
+ */
+function defineProperties(object, properties) {
+
+  // Create a map into which we will copy each verified property from the given
+  // `properties` description map. We use it to verify that none of the
+  // provided properties is marked as a "conflict" property and that all
+  // "required" properties are resolved by a property of an `object`, so we
+  // can throw an exception before mutating object if that isn't the case.
+  var verifiedProperties = {};
+
+  // Coping each property from a given `properties` descriptor map to a
+  // verified map of property descriptors.
+  Object.keys(properties).forEach(function(name) {
+
+    // If property is marked as "required" property and we don't have a same
+    // named property in a given `object` we throw an exception. If `object`
+    // has same named property just skip this property since required property
+    // is was inherited and there for requirement was satisfied.
+    if (isRequiredProperty(properties, name)) {
+      if (!(name in object))
+        throwRequiredPropertyError(name);
+    }
+
+    // If property is marked as "conflict" property we throw an exception.
+    else if (isConflictProperty(properties, name)) {
+      throwConflictPropertyError(name);
+    }
+
+    // If property is not marked neither as "required" nor "conflict" property
+    // we copy it to verified properties map.
+    else {
+      verifiedProperties[name] = properties[name];
+    }
+  });
+
+  // If no exceptions were thrown yet, we know that our verified property
+  // descriptor map has no properties marked as "conflict" or "required",
+  // so we just delegate to the built-in `Object.defineProperties`.
+  return Object.defineProperties(object, verifiedProperties);
+}
+
+/**
+ *  `create` is like `Object.create`, except that it ensures that:
+ *    - An exception is thrown if any property in a given `properties` map
+ *      is marked as "required" property and same named property is not
+ *      found in a given `prototype`.
+ *    - An exception is thrown if any property in a given `properties` map
+ *      is marked as "conflict" property.
+ * @param {Object} prototype
+ *    prototype of the composed object
+ * @param {Object} properties
+ *    Properties descriptor map.
+ * @returns {Object}
+ *    An object that inherits form a given `prototype` and implements all the
+ *    properties defined by a given `properties` descriptor map.
+ */
+function create(prototype, properties) {
+
+  // Creating an instance of the given `prototype`.
+  var object = Object.create(prototype);
+
+  // Overriding `toString`, `constructor` methods if they are just inherited
+  // from `Object.prototype` with a same named methods of the `Trait.prototype`
+  // that will have more relevant behavior.
+  overrideBuiltInMethods(object, Trait.prototype);
+
+  // Trying to define given `properties` on the `object`. We use our custom
+  // `defineProperties` function instead of build-in `Object.defineProperties`
+  // that behaves exactly the same, except that it will throw if any
+  // property in the given `properties` descriptor is marked as "required" or
+  // "conflict" property.
+  return defineProperties(object, properties);
+}
+
+/**
+ * Composes new trait. If two or more traits have own properties with the
+ * same name, the new trait will contain a "conflict" property for that name.
+ * "compose" is a commutative and associative operation, and the order of its
+ * arguments is not significant.
+ *
+ * **Note:** Use `Trait.compose` instead of calling this function with more
+ * than one argument. The multiple-argument functionality is strictly for
+ * backward compatibility.
+ *
+ * @params {Object} trait
+ *    Takes traits as an arguments
+ * @returns {Object}
+ *    New trait containing the combined own properties of all the traits.
+ * @example
+ *    var newTrait = compose(trait_1, trait_2, ..., trait_N)
+ */
+function Trait(trait1, trait2) {
+
+  // If the function was called with one argument, the argument should be
+  // an object whose properties are mapped to property descriptors on a new
+  // instance of Trait, so we delegate to the trait function.
+  // If the function was called with more than one argument, those arguments
+  // should be instances of Trait or plain property descriptor maps
+  // whose properties should be mixed into a new instance of Trait,
+  // so we delegate to the compose function.
+
+  return trait2 === undefined ? trait(trait1) : compose.apply(null, arguments);
+}
+
+Object.freeze(Object.defineProperties(Trait.prototype, {
+  toString: {
+    value: function toString() {
+      return "[object " + this.constructor.name + "]";
+    }
+  },
+
+  /**
+   * `create` is like `Object.create`, except that it ensures that:
+   *    - An exception is thrown if this trait defines a property that is
+   *      marked as required property and same named property is not
+   *      found in a given `prototype`.
+   *    - An exception is thrown if this trait contains property that is
+   *      marked as "conflict" property.
+   * @param {Object}
+   *    prototype of the compared object
+   * @returns {Object}
+   *    An object with all of the properties described by the trait.
+   */
+  create: {
+    value: function createTrait(prototype) {
+      return create(undefined === prototype ? Object.prototype : prototype,
+                    this);
+    },
+    enumerable: true
+  },
+
+  /**
+   * Composes a new resolved trait, with all the same properties as the original
+   * trait, except that all properties whose name is an own property of
+   * `resolutions` will be renamed to the value of `resolutions[name]`. If
+   * `resolutions[name]` is `null`, the property is marked as "required".
+   * @param {Object} resolutions
+   *   An object whose own properties serve as a mapping from old names to new
+   *   names, or to `null` if the property should be excluded.
+   * @returns {Object}
+   *   New trait with the same own properties as the original trait but renamed.
+   */
+  resolve: {
+    value: function resolveTrait(resolutions) {
+      return resolve(resolutions, this);
+    },
+    enumerable: true
+  }
+}));
+
+/**
+ * @see compose
+ */
+Trait.compose = Object.freeze(compose);
+Object.freeze(compose.prototype);
+
+/**
+ * Constant singleton, representing placeholder for required properties.
+ * @type {Object}
+ */
+Trait.required = Object.freeze(Object.create(Object.prototype, {
+  toString: {
+    value: Object.freeze(function toString() {
+      return "<Trait.required>";
+    })
+  }
+}));
+Object.freeze(Trait.required.toString.prototype);
+
+exports.Trait = Object.freeze(Trait);
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/list.js b/tools/addon-sdk-1.3/packages/api-utils/lib/list.js
new file mode 100644
index 0000000..8643a0a
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/list.js
@@ -0,0 +1,147 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { Trait } = require('./traits');
+
+/**
+ * @see https://jetpack.mozillalabs.com/sdk/latest/docs/#module/api-utils/list
+ */
+const Iterable = Trait.compose({
+  /**
+   * Hash map of key-values to iterate over.
+   * Note: That this property can be a getter if you need dynamic behavior.
+   * @type {Object}
+   */
+  _keyValueMap: Trait.required,
+  /**
+   * Custom iterator providing `Iterable`s enumeration behavior.
+   * @param {Boolean} onKeys
+   */
+  __iterator__: function __iterator__(onKeys, onKeyValue) {
+    let map = this._keyValueMap;
+    for (let key in map)
+      yield onKeyValue ? [key, map[key]] : onKeys ? key : map[key];
+  }
+});
+exports.Iterable = Iterable;
+
+/**
+ * An ordered collection (also known as a sequence) disallowing duplicate
+ * elements. List is composed out of `Iterable` there for it provides custom
+ * enumeration behavior that is similar to array (enumerates only on the
+ * elements of the list). List is a base trait and is meant to be a part of
+ * composition, since all of it's API is private except length property.
+ */
+const List = Trait.resolve({ toString: null }).compose({
+  _keyValueMap: null,
+  /**
+   * List constructor can take any number of element to populate itself.
+   * @params {Object|String|Number} element
+   * @example
+   *    List(1,2,3).length == 3 // true
+   */
+  constructor: function List() {
+    this._keyValueMap = [];
+    for (let i = 0, ii = arguments.length; i < ii; i++)
+      this._add(arguments[i]);
+  },
+  /**
+   * Number of elements in this list.
+   * @type {Number}
+   */
+  get length() this._keyValueMap.length,
+   /**
+    * Returns a string representing this list.
+    * @returns {String}
+    */
+  toString: function toString() 'List(' + this._keyValueMap + ')',
+  /**
+   * Returns `true` if this list contains the specified `element`.
+   * @param {Object|Number|String} element
+   * @returns {Boolean}
+   */
+  _has: function _has(element) 0 <= this._keyValueMap.indexOf(element),
+  /**
+   * Appends the specified `element` to the end of this list, if it doesn't
+   * contains it. Ignores the call if `element` is already contained.
+   * @param {Object|Number|String} element
+   */
+  _add: function _add(element) {
+    let list = this._keyValueMap,
+        index = list.indexOf(element);
+    if (0 > index)
+      list.push(this._public[list.length] = element);
+  },
+  /**
+   * Removes specified `element` from this list, if it contains it.
+   * Ignores the call if `element` is not contained.
+   * @param {Object|Number|String} element
+   */
+  _remove: function _remove(element) {
+    let list = this._keyValueMap,
+        index = list.indexOf(element);
+    if (0 <= index) {
+      delete this._public[list.length - 1];
+      list.splice(index, 1);
+      for (let length = list.length; index < length; index++)
+        this._public[index] = list[index];
+    }
+  },
+  /**
+   * Removes all of the elements from this list.
+   */
+  _clear: function _clear() {
+    for (let i = 0, ii = this._keyValueMap.length; i < ii; i ++)
+      delete this._public[i];
+    this._keyValueMap.splice(0);
+  },
+  /**
+   * Custom iterator providing `List`s enumeration behavior.
+   * We cant reuse `_iterator` that is defined by `Iterable` since it provides
+   * iteration in an arbitrary order.
+   * @see https://developer.mozilla.org/en/JavaScript/Reference/Statements/for...in
+   * @param {Boolean} onKeys
+   */
+  __iterator__: function __iterator__(onKeys, onKeyValue) {
+    let array = this._keyValueMap.slice(0),
+        i = -1;
+    for each(let element in array)
+      yield onKeyValue ? [++i, element] : onKeys ? ++i : element;
+  }
+});
+exports.List = List;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/match-pattern.js b/tools/addon-sdk-1.3/packages/api-utils/lib/match-pattern.js
new file mode 100644
index 0000000..802fe3a
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/match-pattern.js
@@ -0,0 +1,137 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Nickolay Ponomarev.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Nickolay Ponomarev <asqueella@gmail.com> (Original Author)
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *   Drew Willcoxon <adw@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+const { URL } = require("./url");
+
+exports.MatchPattern = MatchPattern;
+
+function MatchPattern(pattern) {
+  if (typeof pattern.test == "function") {
+
+    // For compatibility with -moz-document rules, we require the RegExp's
+    // global, ignoreCase, and multiline flags to be set to false.
+    if (pattern.global) {
+      throw new Error("A RegExp match pattern cannot be set to `global` " +
+                      "(i.e. //g).");
+    }
+    if (pattern.ignoreCase) {
+      throw new Error("A RegExp match pattern cannot be set to `ignoreCase` " +
+                      "(i.e. //i).");
+    }
+    if (pattern.multiline) {
+      throw new Error("A RegExp match pattern cannot be set to `multiline` " +
+                      "(i.e. //m).");
+    }
+
+    this.regexp = pattern;
+  }
+  else {
+    let firstWildcardPosition = pattern.indexOf("*");
+    let lastWildcardPosition = pattern.lastIndexOf("*");
+    if (firstWildcardPosition != lastWildcardPosition)
+      throw new Error("There can be at most one '*' character in a wildcard.");
+
+    if (firstWildcardPosition == 0) {
+      if (pattern.length == 1)
+        this.anyWebPage = true;
+      else if (pattern[1] != ".")
+        throw new Error("Expected a *.<domain name> string, got: " + pattern);
+      else
+        this.domain = pattern.substr(2);
+    }
+    else {
+      if (pattern.indexOf(":") == -1) {
+        throw new Error("When not using *.example.org wildcard, the string " +
+                        "supplied is expected to be either an exact URL to " +
+                        "match or a URL prefix. The provided string ('" +
+                        pattern + "') is unlikely to match any pages.");
+      }
+
+      if (firstWildcardPosition == -1)
+        this.exactURL = pattern;
+      else if (firstWildcardPosition == pattern.length - 1)
+        this.urlPrefix = pattern.substr(0, pattern.length - 1);
+      else {
+        throw new Error("The provided wildcard ('" + pattern + "') has a '*' " +
+                        "in an unexpected position. It is expected to be the " +
+                        "first or the last character in the wildcard.");
+      }
+    }
+  }
+}
+
+MatchPattern.prototype = {
+
+  test: function MatchPattern_test(urlStr) {
+    try {
+      var url = URL(urlStr);
+    }
+    catch (err) {
+      return false;
+    }
+
+    // Test the URL against a RegExp pattern.  For compatibility with
+    // -moz-document rules, we require the RegExp to match the entire URL,
+    // so we not only test for a match, we also make sure the matched string
+    // is the entire URL string.
+    //
+    // Assuming most URLs don't match most match patterns, we call `test` for
+    // speed when determining whether or not the URL matches, then call `exec`
+    // for the small subset that match to make sure the entire URL matches.
+    //
+    if (this.regexp && this.regexp.test(urlStr) &&
+        this.regexp.exec(urlStr)[0] == urlStr)
+      return true;
+
+    if (this.anyWebPage && /^(https?|ftp)$/.test(url.scheme))
+      return true;
+    if (this.exactURL && this.exactURL == urlStr)
+      return true;
+    if (this.domain && url.host &&
+        url.host.slice(-this.domain.length) == this.domain)
+      return true;
+    if (this.urlPrefix && 0 == urlStr.indexOf(this.urlPrefix))
+      return true;
+
+    return false;
+  }
+
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/memory.js b/tools/addon-sdk-1.3/packages/api-utils/lib/memory.js
new file mode 100644
index 0000000..2ff0486
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/memory.js
@@ -0,0 +1,146 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci,Cu,components} = require("chrome");
+var trackedObjects = {};
+
+var Compacter = {
+  INTERVAL: 5000,
+  notify: function(timer) {
+    var newTrackedObjects = {};
+    for (let name in trackedObjects) {
+      var oldBin = trackedObjects[name];
+      var newBin = [];
+      var strongRefs = [];
+      for (var i = 0; i < oldBin.length; i++) {
+        var strongRef = oldBin[i].weakref.get();
+        if (strongRef && strongRefs.indexOf(strongRef) == -1) {
+          strongRefs.push(strongRef);
+          newBin.push(oldBin[i]);
+        }
+      }
+      if (newBin.length)
+        newTrackedObjects[name] = newBin;
+    }
+    trackedObjects = newTrackedObjects;
+  }
+};
+
+var timer = Cc["@mozilla.org/timer;1"]
+            .createInstance(Ci.nsITimer);
+
+timer.initWithCallback(Compacter,
+                       Compacter.INTERVAL,
+                       Ci.nsITimer.TYPE_REPEATING_SLACK);
+
+var track = exports.track = function track(object, bin, stackFrameNumber) {
+  var frame = components.stack.caller;
+  var weakref = Cu.getWeakReference(object);
+  if (!bin)
+    bin = object.constructor.name;
+  if (bin == "Object")
+    bin = frame.name;
+  if (!bin)
+    bin = "generic";
+  if (!(bin in trackedObjects))
+    trackedObjects[bin] = [];
+
+  if (stackFrameNumber > 0)
+    for (var i = 0; i < stackFrameNumber; i++)
+      frame = frame.caller;
+
+  trackedObjects[bin].push({weakref: weakref,
+                            created: new Date(),
+                            filename: frame.filename,
+                            lineNo: frame.lineNumber,
+                            bin: bin});
+};
+
+var getBins = exports.getBins = function getBins() {
+  var names = [];
+  for (let name in trackedObjects)
+    names.push(name);
+  return names;
+};
+
+var getObjects = exports.getObjects = function getObjects(bin) {
+  function getLiveObjectsInBin(bin, array) {
+    for (var i = 0; i < bin.length; i++) {
+      var object = bin[i].weakref.get();
+      if (object)
+        array.push(bin[i]);
+    }
+  }
+
+  var results = [];
+  if (bin) {
+    if (bin in trackedObjects)
+      getLiveObjectsInBin(trackedObjects[bin], results);
+  } else
+    for (let name in trackedObjects)
+      getLiveObjectsInBin(trackedObjects[name], results);
+  return results;
+};
+
+var gc = exports.gc = function gc() {
+  // Components.utils.forceGC() doesn't currently perform
+  // cycle collection, which means that e.g. DOM elements
+  // won't be collected by it. Fortunately, there are
+  // other ways...
+
+  var window = Cc["@mozilla.org/appshell/appShellService;1"]
+               .getService(Ci.nsIAppShellService)
+               .hiddenDOMWindow;
+  var test_utils = window.QueryInterface(Ci.nsIInterfaceRequestor)
+                   .getInterface(Ci.nsIDOMWindowUtils);
+  test_utils.garbageCollect();
+  Compacter.notify();
+
+  // Not sure why, but sometimes it appears that we don't get
+  // them all with just one CC, so let's do it again.
+  test_utils.garbageCollect();
+};
+
+require("./unload").when(
+  function() {
+    trackedObjects = {};
+    if (timer) {
+      timer.cancel();
+      timer = null;
+    }
+  });
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/observer-service.js b/tools/addon-sdk-1.3/packages/api-utils/lib/observer-service.js
new file mode 100644
index 0000000..3bcd126
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/observer-service.js
@@ -0,0 +1,211 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Observers.
+ *
+ * The Initial Developer of the Original Code is Daniel Aquino.
+ * Portions created by the Initial Developer are Copyright (C) 2008
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Daniel Aquino <mr.danielaquino@gmail.com>
+ *   Myk Melez <myk@mozilla.org>
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci} = require("chrome");
+var xpcom = require("./xpcom");
+
+/**
+ * A service for adding, removing and notifying observers of notifications.
+ * Wraps the nsIObserverService interface.
+ *
+ * @version 0.2
+ */
+
+var service = Cc["@mozilla.org/observer-service;1"].
+              getService(Ci.nsIObserverService);
+
+/**
+ * A cache of observers that have been added.
+ *
+ * We use this to remove observers when a caller calls |Observers.remove|.
+ */
+var cache = [];
+
+/**
+ * Topics specifically available to Jetpack-generated extensions.
+ *
+ * Using these predefined consts instead of the platform strings is good:
+ *   - allows us to scope topics specifically for Jetpacks
+ *   - addons aren't dependent on strings nor behavior of core platform topics
+ *   - the core platform topics are not clearly named
+ *
+ */
+exports.topics = {
+  /**
+   * A topic indicating that the application is in a state usable
+   * by add-ons.
+   */
+  get APPLICATION_READY() packaging.jetpackID + "_APPLICATION_READY"
+};
+
+/**
+ * Register the given callback as an observer of the given topic.
+ *
+ * @param   topic       {String}
+ *          the topic to observe
+ *
+ * @param   callback    {Object}
+ *          the callback; an Object that implements nsIObserver or a Function
+ *          that gets called when the notification occurs
+ *
+ * @param   thisObject  {Object}  [optional]
+ *          the object to use as |this| when calling a Function callback
+ *
+ * @returns the observer
+ */
+var add = exports.add = function add(topic, callback, thisObject) {
+  var observer = new Observer(topic, callback, thisObject);
+  service.addObserver(observer, topic, true);
+  cache.push(observer);
+
+  return observer;
+};
+
+/**
+ * Unregister the given callback as an observer of the given topic.
+ *
+ * @param   topic       {String}
+ *          the topic being observed
+ *
+ * @param   callback    {Object}
+ *          the callback doing the observing
+ *
+ * @param   thisObject  {Object}  [optional]
+ *          the object being used as |this| when calling a Function callback
+ */
+var remove = exports.remove = function remove(topic, callback, thisObject) {
+  // This seems fairly inefficient, but I'm not sure how much better
+  // we can make it.  We could index by topic, but we can't index by callback
+  // or thisObject, as far as I know, since the keys to JavaScript hashes
+  // (a.k.a. objects) can apparently only be primitive values.
+  var [observer] = cache.filter(function(v) {
+                                  return (v.topic      == topic    &&
+                                          v.callback   == callback &&
+                                          v.thisObject == thisObject);
+                                });
+  if (observer) {
+    service.removeObserver(observer, topic);
+    cache.splice(cache.indexOf(observer), 1);
+  }
+};
+
+/**
+ * Notify observers about something.
+ *
+ * @param topic   {String}
+ *        the topic to notify observers about
+ *
+ * @param subject {Object}  [optional]
+ *        some information about the topic; can be any JS object or primitive
+ *
+ * @param data    {String}  [optional] [deprecated]
+ *        some more information about the topic; deprecated as the subject
+ *        is sufficient to pass all needed information to the JS observers
+ *        that this module targets; if you have multiple values to pass to
+ *        the observer, wrap them in an object and pass them via the subject
+ *        parameter (i.e.: { foo: 1, bar: "some string", baz: myObject })
+ */
+var notify = exports.notify = function notify(topic, subject, data) {
+  subject = (typeof subject == "undefined") ? null : new Subject(subject);
+  data = (typeof    data == "undefined") ? null : data;
+  service.notifyObservers(subject, topic, data);
+};
+
+function Observer(topic, callback, thisObject) {
+  memory.track(this);
+  this.topic = topic;
+  this.callback = callback;
+  this.thisObject = thisObject;
+}
+
+Observer.prototype = {
+  QueryInterface: xpcom.utils.generateQI([Ci.nsIObserver,
+                                          Ci.nsISupportsWeakReference]),
+  observe: function(subject, topic, data) {
+    // Extract the wrapped object for subjects that are one of our
+    // wrappers around a JS object.  This way we support both wrapped
+    // subjects created using this module and those that are real
+    // XPCOM components.
+    if (subject && typeof subject == "object" &&
+        ("wrappedJSObject" in subject) &&
+        ("observersModuleSubjectWrapper" in subject.wrappedJSObject))
+      subject = subject.wrappedJSObject.object;
+
+    try {
+      if (typeof this.callback == "function") {
+        if (this.thisObject)
+          this.callback.call(this.thisObject, subject, data);
+        else
+          this.callback(subject, data);
+      } else // typeof this.callback == "object" (nsIObserver)
+        this.callback.observe(subject, topic, data);
+    } catch (e) {
+      console.exception(e);
+    }
+  }
+};
+
+function Subject(object) {
+  // Double-wrap the object and set a property identifying the
+  // wrappedJSObject as one of our wrappers to distinguish between
+  // subjects that are one of our wrappers (which we should unwrap
+  // when notifying our observers) and those that are real JS XPCOM
+  // components (which we should pass through unaltered).
+  this.wrappedJSObject = {
+    observersModuleSubjectWrapper: true,
+    object: object
+  };
+}
+
+Subject.prototype = {
+  QueryInterface: xpcom.utils.generateQI([]),
+  getHelperForLanguage: function() {},
+  getInterfaces: function() {}
+};
+
+require("./unload").when(
+  function removeAllObservers() {
+    // Make a copy of cache first, since cache will be changing as we
+    // iterate through it.
+    cache.slice().forEach(
+      function(observer) {
+        remove(observer.topic, observer.callback, observer.thisObject);
+      });
+  });
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/passwords/utils.js b/tools/addon-sdk-1.3/packages/api-utils/lib/passwords/utils.js
new file mode 100644
index 0000000..950aac2
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/passwords/utils.js
@@ -0,0 +1,134 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack Packages.
+ *
+ * The Initial Developer of the Original Code is Red Hat.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Matěj Cepl <mcepl@redhat.com> (Original Author)
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Cc, Ci, components: { Constructor: CConstructor } } = require("chrome");
+const { uri: ADDON_URI } = require("self");
+const loginManager = Cc["@mozilla.org/login-manager;1"].
+                     getService(Ci.nsILoginManager);
+const { URL: parseURL } = require("../url");
+const LoginInfo = CConstructor("@mozilla.org/login-manager/loginInfo;1",
+                               "nsILoginInfo", "init");
+
+function filterMatchingLogins(loginInfo)
+  Object.keys(this).every(function(key) loginInfo[key] === this[key], this);
+
+/**
+ * Removes `user`, `password` and `path` fields from the given `url` if it's
+ * 'http', 'https' or 'ftp'. All other URLs are returned unchanged.
+ * @example
+ * http://user:pass@www.site.com/foo/?bar=baz#bang -> http://www.site.com
+ */
+function normalizeURL(url) {
+  let { scheme, host, port } = parseURL(url);
+  // We normalize URL only if it's `http`, `https` or `ftp`. All other types of
+  // URLs (`resource`, `chrome`, etc..) should not be normalized as they are
+  // used with add-on associated credentials path.
+  return scheme === "http" || scheme === "https" || scheme === "ftp" ?
+         scheme + "://" + (host || "") + (port ? ":" + port : "") :
+         url
+}
+
+function Login(options) {
+  let login = Object.create(Login.prototype);
+  Object.keys(options || {}).forEach(function(key) {
+    if (key === 'url')
+      login.hostname = normalizeURL(options.url);
+    else if (key === 'formSubmitURL')
+      login.formSubmitURL = options.formSubmitURL ?
+                            normalizeURL(options.formSubmitURL) : null;
+    else if (key === 'realm')
+      login.httpRealm = options.realm;
+    else 
+      login[key] = options[key];
+  });
+
+  return login;
+}
+Login.prototype.toJSON = function toJSON() {
+  return {
+    url: this.hostname || ADDON_URI,
+    realm: this.httpRealm || null,
+    formSubmitURL: this.formSubmitURL || null,
+    username: this.username || null,
+    password: this.password || null,
+    usernameField: this.usernameField || '',
+    passwordField: this.passwordField || '',
+  }
+};
+Login.prototype.toLoginInfo = function toLoginInfo() {
+  let { url, realm, formSubmitURL, username, password, usernameField,
+        passwordField } = this.toJSON();
+
+  return new LoginInfo(url, formSubmitURL, realm, username, password,
+                       usernameField, passwordField);
+};
+
+function loginToJSON(value) Login(value).toJSON()
+
+/**
+ * Returns array of `nsILoginInfo` objects that are stored in the login manager
+ * and have all the properties with matching values as a given `options` object.
+ * @param {Object} options
+ * @returns {nsILoginInfo[]}
+ */
+exports.search = function search(options) {
+  return loginManager.getAllLogins()
+                     .filter(filterMatchingLogins, Login(options))
+                     .map(loginToJSON);
+};
+
+/**
+ * Stores login info created from the given `options` to the applications
+ * built-in login management system.
+ * @param {Object} options.
+ */
+exports.store = function store(options) {
+  loginManager.addLogin(Login(options).toLoginInfo());
+};
+
+/**
+ * Removes login info from the applications built-in login management system.
+ * _Please note: When removing a login info the specified properties must
+ * exactly match to the one that is already stored or exception will be thrown._
+ * @param {Object} options.
+ */
+exports.remove = function remove(options) {
+  loginManager.removeLogin(Login(options).toLoginInfo());
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/plain-text-console.js b/tools/addon-sdk-1.3/packages/api-utils/lib/plain-text-console.js
new file mode 100644
index 0000000..f7ea74e
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/plain-text-console.js
@@ -0,0 +1,114 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci} = require("chrome");
+
+function stringify(arg) {
+  try {
+    return String(arg);
+  }
+  catch(ex) {
+    return "<toString() error>";
+  }
+}
+
+function stringifyArgs(args) {
+  return Array.map(args, stringify).join(" ");
+}
+
+function message(print, level, args) {
+  print(level + ": " + stringifyArgs(args) + "\n", level);
+}
+
+var Console = exports.PlainTextConsole = function PlainTextConsole(print) {
+  if (!print)
+    print = dump;
+  if (print === dump) {
+    // If we're just using dump(), auto-enable preferences so
+    // that the developer actually sees the console output.
+    var prefs = Cc["@mozilla.org/preferences-service;1"]
+                .getService(Ci.nsIPrefBranch);
+    prefs.setBoolPref("browser.dom.window.dump.enabled", true);
+  }
+  this.print = print;
+
+  // Binding all the public methods to an instance so that they can be used
+  // as callback / listener functions straightaway.
+  this.log = this.log.bind(this);
+  this.info = this.info.bind(this);
+  this.warn = this.warn.bind(this);
+  this.error = this.error.bind(this);
+  this.debug = this.debug.bind(this);
+  this.exception = this.exception.bind(this);
+  this.trace = this.trace.bind(this);
+};
+
+Console.prototype = {
+  log: function log() {
+    message(this.print, "info", arguments);
+  },
+
+  info: function info() {
+    message(this.print, "info", arguments);
+  },
+
+  warn: function warn() {
+    message(this.print, "warning", arguments);
+  },
+
+  error: function error() {
+    message(this.print, "error", arguments);
+  },
+
+  debug: function debug() {
+    message(this.print, "debug", arguments);
+  },
+
+  exception: function exception(e) {
+    var fullString = ("An exception occurred.\n" +
+                      require("./traceback").format(e) + "\n" + e);
+    this.error(fullString);
+  },
+
+  trace: function trace() {
+    var traceback = require("./traceback");
+    var stack = traceback.get();
+    stack.splice(-1, 1);
+    message(this.print, "info", [traceback.format(stack)]);
+  }
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/preferences-service.js b/tools/addon-sdk-1.3/packages/api-utils/lib/preferences-service.js
new file mode 100644
index 0000000..127a1cf
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/preferences-service.js
@@ -0,0 +1,138 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Preferences.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2008
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Myk Melez <myk@mozilla.org>
+ *   Daniel Aquino <mr.danielaquino@gmail.com>
+ *   Atul Varma <atul@mozilla.com>
+ *   Erik Vold <erikvvold@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// The minimum and maximum integers that can be set as preferences.
+// The range of valid values is narrower than the range of valid JS values
+// because the native preferences code treats integers as NSPR PRInt32s,
+// which are 32-bit signed integers on all platforms.
+const MAX_INT = 0x7FFFFFFF;
+const MIN_INT = -0x80000000;
+
+const {Cc,Ci,Cr} = require("chrome");
+
+var prefSvc = Cc["@mozilla.org/preferences-service;1"].
+              getService(Ci.nsIPrefService).getBranch(null);
+
+var get = exports.get = function get(name, defaultValue) {
+  switch (prefSvc.getPrefType(name)) {
+  case Ci.nsIPrefBranch.PREF_STRING:
+    return prefSvc.getComplexValue(name, Ci.nsISupportsString).data;
+
+  case Ci.nsIPrefBranch.PREF_INT:
+    return prefSvc.getIntPref(name);
+
+  case Ci.nsIPrefBranch.PREF_BOOL:
+    return prefSvc.getBoolPref(name);
+
+  case Ci.nsIPrefBranch.PREF_INVALID:
+    return defaultValue;
+
+  default:
+    // This should never happen.
+    throw new Error("Error getting pref " + name +
+                    "; its value's type is " +
+                    prefSvc.getPrefType(name) +
+                    ", which I don't know " +
+                    "how to handle.");
+  }
+};
+
+var set = exports.set = function set(name, value) {
+  var prefType;
+  if (typeof value != "undefined" && value != null)
+    prefType = value.constructor.name;
+
+  switch (prefType) {
+  case "String":
+    {
+      var string = Cc["@mozilla.org/supports-string;1"].
+                   createInstance(Ci.nsISupportsString);
+      string.data = value;
+      prefSvc.setComplexValue(name, Ci.nsISupportsString, string);
+    }
+    break;
+
+  case "Number":
+    // We throw if the number is outside the range or not an integer, since
+    // the result will not be what the consumer wanted to store.
+    if (value > MAX_INT || value < MIN_INT)
+      throw new Error("you cannot set the " + name +
+                      " pref to the number " + value +
+                      ", as number pref values must be in the signed " +
+                      "32-bit integer range -(2^31) to 2^31-1.  " +
+                      "To store numbers outside that range, store " +
+                      "them as strings.");
+    if (value % 1 != 0)
+      throw new Error("cannot store non-integer number: " + value);
+    prefSvc.setIntPref(name, value);
+    break;
+
+  case "Boolean":
+    prefSvc.setBoolPref(name, value);
+    break;
+
+  default:
+    throw new Error("can't set pref " + name + " to value '" + value +
+                    "'; it isn't a string, integer, or boolean");
+  }
+};
+
+var has = exports.has = function has(name) {
+  return (prefSvc.getPrefType(name) != Ci.nsIPrefBranch.PREF_INVALID);
+};
+
+var isSet = exports.isSet = function isSet(name) {
+  return (has(name) && prefSvc.prefHasUserValue(name));
+};
+
+var reset = exports.reset = function reset(name) {
+  try {
+    prefSvc.clearUserPref(name);
+  } catch (e if e.result == Cr.NS_ERROR_UNEXPECTED) {
+    // The pref service throws NS_ERROR_UNEXPECTED when the caller tries
+    // to reset a pref that doesn't exist or is already set to its default
+    // value.  This interface fails silently in those cases, so callers
+    // can unconditionally reset a pref without having to check if it needs
+    // resetting first or trap exceptions after the fact.  It passes through
+    // other exceptions, however, so callers know about them, since we don't
+    // know what other exceptions might be thrown and what they might mean.
+  }
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/runtime.js b/tools/addon-sdk-1.3/packages/api-utils/lib/runtime.js
new file mode 100644
index 0000000..135617e
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/runtime.js
@@ -0,0 +1,48 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Cc, Ci } = require("chrome");
+const runtime = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime);
+
+exports.inSafeMode = runtime.inSafeMode;
+exports.OS = runtime.OS;
+exports.processType = runtime.processType;
+exports.widgetToolkit = runtime.widgetToolkit;
+exports.XPCOMABI = runtime.XPCOMABI;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/securable-module.js b/tools/addon-sdk-1.3/packages/api-utils/lib/securable-module.js
new file mode 100644
index 0000000..ea4df1a
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/securable-module.js
@@ -0,0 +1,782 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2009-2010 the Mozilla Foundation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of the Mozilla Foundation nor the names
+ *    of its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+(function(global) {
+   const Cc = Components.classes;
+   const Ci = Components.interfaces;
+   const Cu = Components.utils;
+   const Cr = Components.results;
+
+   var exports = {};
+
+   var ios = Cc['@mozilla.org/network/io-service;1']
+             .getService(Ci.nsIIOService);
+
+   var systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
+                         .createInstance(Ci.nsIPrincipal);
+
+   // Even though manifest.py does some dependency scanning, that
+   // scan is done as part of an evaluation of what the add-on needs
+   // for security purposes. The following regexps are used to scan for
+   // dependencies inside a simplified define() callback:
+   // define(function(require, exports, module){ var a = require('a'); });
+   // and are used at runtime ensure the dependencies needed by
+   // the define factory function are already evaluated and ready.
+   // Even though this loader is a sync loader, and could fetch the module
+   // as the require() call happens, it would differ in behavior as
+   // compared to the async browser case, which would make sure to execute
+   // the dependencies first before executing the define() factory function.
+   // So this dependency scanning and evaluation is kept to match the
+   // async behavior.
+   var commentRegExp = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg;
+   var cjsRequireRegExp = /require\(["']([\w\!\-_\.\/]+)["']\)/g;
+   var cjsStandardDeps = ['require', 'exports', 'module'];
+
+   function resolvePrincipal(principal, defaultPrincipal) {
+     if (principal === undefined)
+       return defaultPrincipal;
+     if (principal == "system")
+       return systemPrincipal;
+     return principal;
+   }
+
+   // The base URI to we use when we're given relative URLs, if any.
+   var baseURI = null;
+   if (global.window)
+     baseURI = ios.newURI(global.location.href, null, null);
+   exports.baseURI = baseURI;
+
+   // The "parent" chrome URI to use if we're loading code that
+   // needs chrome privileges but may not have a filename that
+   // matches any of SpiderMonkey's defined system filename prefixes.
+   // The latter is needed so that wrappers can be automatically
+   // made for the code. For more information on this, see
+   // bug 418356:
+   //
+   // https://bugzilla.mozilla.org/show_bug.cgi?id=418356
+   var parentChromeURIString;
+   if (baseURI)
+     // We're being loaded from a chrome-privileged document, so
+     // use its URL as the parent string.
+     parentChromeURIString = baseURI.spec;
+   else
+     // We're being loaded from a chrome-privileged JS module or
+     // SecurableModule, so use its filename (which may itself
+     // contain a reference to a parent).
+     parentChromeURIString = Components.stack.filename;
+
+   function maybeParentifyFilename(filename) {
+     var doParentifyFilename = true;
+     try {
+       // TODO: Ideally we should just make
+       // nsIChromeRegistry.wrappersEnabled() available from script
+       // and use it here. Until that's in the platform, though,
+       // we'll play it safe and parentify the filename unless
+       // we're absolutely certain things will be ok if we don't.
+       var filenameURI = ios.newURI(options.filename,
+                                    null,
+                                    baseURI);
+       if (filenameURI.scheme == 'chrome' &&
+           filenameURI.path.indexOf('/content/') == 0)
+         // Content packages will always have wrappers made for them;
+         // if automatic wrappers have been disabled for the
+         // chrome package via a chrome manifest flag, then
+         // this still works too, to the extent that the
+         // content package is insecure anyways.
+         doParentifyFilename = false;
+     } catch (e) {}
+     if (doParentifyFilename)
+       return parentChromeURIString + " -> " + filename;
+     return filename;
+   }
+
+   function getRootDir(urlStr) {
+     // TODO: This feels hacky, and like there will be edge cases.
+     return urlStr.slice(0, urlStr.lastIndexOf("/") + 1);
+   }
+
+   exports.SandboxFactory = function SandboxFactory(defaultPrincipal) {
+     // Unless specified otherwise, use a principal with limited
+     // privileges.
+     this._defaultPrincipal = resolvePrincipal(defaultPrincipal,
+                                               "http://www.mozilla.org");
+   },
+
+   exports.SandboxFactory.prototype = {
+     createSandbox: function createSandbox(options) {
+       var principal = resolvePrincipal(options.principal,
+                                        this._defaultPrincipal);
+
+       return {
+         _sandbox: new Cu.Sandbox(principal,
+                                  options.filename ?
+                                    { sandboxName: options.filename } :
+                                    { }
+                                 ),
+         _principal: principal,
+         get globalScope() {
+           return this._sandbox;
+         },
+         defineProperty: function defineProperty(name, value) {
+           this._sandbox[name] = value;
+         },
+         getProperty: function getProperty(name) {
+           return this._sandbox[name];
+         },
+         evaluate: function evaluate(options) {
+           if (typeof(options) == 'string')
+             options = {contents: options};
+           options = {__proto__: options};
+           if (typeof(options.contents) != 'string')
+             throw new Error('Expected string for options.contents');
+           if (options.lineNo === undefined)
+             options.lineNo = 1;
+           if (options.jsVersion === undefined)
+             options.jsVersion = "1.8";
+           if (typeof(options.filename) != 'string')
+             options.filename = '<string>';
+
+           if (this._principal == systemPrincipal)
+             options.filename = maybeParentifyFilename(options.filename);
+
+           return Cu.evalInSandbox(options.contents,
+                                   this._sandbox,
+                                   options.jsVersion,
+                                   options.filename,
+                                   options.lineNo);
+         }
+       };
+     }
+   };
+
+   exports.Loader = function Loader(options) {
+     options = {__proto__: options};
+     if (options.fs === undefined) {
+       var rootPaths = options.rootPath || options.rootPaths;
+       if (rootPaths) {
+         if (rootPaths.constructor.name != "Array")
+           rootPaths = [rootPaths];
+         var fses = [new exports.LocalFileSystem(path)
+                     for each (path in rootPaths)];
+         options.fs = new exports.CompositeFileSystem({
+           fses: fses,
+           metadata: options.metadata,
+           uriPrefix: options.uriPrefix,
+           name: options.name
+         });
+       } else
+         options.fs = new exports.LocalFileSystem();
+     }
+     if (options.sandboxFactory === undefined)
+       options.sandboxFactory = new exports.SandboxFactory(
+         options.defaultPrincipal
+       );
+     if ('modules' in options)
+       throw new Error('options.modules is no longer supported');
+     // pathAccessed used to know if a module was accessed/required
+     // by another module, and in that case, assigning the module value
+     // via a define callback is not allowed.
+     if (options.pathAccessed === undefined)
+       options.pathAccessed = {};
+     if (options.globals === undefined)
+       options.globals = {};
+
+     this.fs = options.fs;
+     this.sandboxFactory = options.sandboxFactory;
+     this.sandboxes = {};
+     this.modules = {};
+     this.pathAccessed = options.pathAccessed;
+     this.defineUsed = {};
+     this.globals = options.globals;
+     this.getModuleExports = options.getModuleExports;
+     this.modifyModuleSandbox = options.modifyModuleSandbox;
+     this.manifest = options.manifest || {};
+   };
+
+   exports.Loader.prototype = {
+     _makeApi: function _makeApi(basePath) {
+       /*
+        * _makeApi() creates a pair of specialized require()/define()
+        * functions for use by the code that comes from 'basePath' (which is
+        * a resource: URI pointing to some module, e.g. main.js). This
+        * require/define pair knows what main.js is allowed to import, in
+        * particular it knows what the link-time module search algorithm has
+        * found for each imported name (so if they require "panel", they'll
+        * get the one from addon-kit, not from some other package).
+        *
+        * When some other module (e.g. panel.js) is loaded, they'll get a
+        * different require/define pair, specialized for them.
+        */
+       var self = this;
+       let reqs;
+       if (basePath && (basePath in self.manifest))
+         reqs = self.manifest[basePath].requirements;
+
+       function syncRequire(module) {
+         if (reqs) {
+           // if we know about you, you must follow the manifest
+           if (module in reqs)
+             return loadMaybeMagicModule(module, reqs[module]);
+           // if you invoke chrome, you can go off-manifest and search
+           if ("chrome" in reqs)
+             return loadMaybeMagicModule(module, null);
+           throw new Error("Module at "+basePath+" not allowed to require"+"("+module+")");
+         } else {
+           // if we don't know about you, you can do anything you want.
+           // You're going to have to search for your own modules, though.
+           return loadMaybeMagicModule(module, null);
+         }
+       }
+
+       function loadMaybeMagicModule(moduleName, moduleData) {
+         /*
+          * If we get here, we're allowed to import this module, we just have
+          * to figure out how.
+          *
+          * 'moduleName' is the unmodified argument passed to require(),
+          * so it might be "panel" or "pkg/foo" or even "./bar" for relative
+          * imports. 'moduleData' is the manifest entry that tells us how
+          * we're supposed to import this module: usually it's an object with
+          * a .uri, but for certain "magic" modules it might be empty. If
+          * it's 'null' then we're supposed to search all known packages for
+          * it.
+          */
+
+         if (self.getModuleExports) {
+           /* this currently handles 'chrome' */
+           let exports = self.getModuleExports(basePath, moduleName);
+           if (exports)
+             return exports;
+         }
+         if (moduleName == "self") {
+           /* The 'self' module is magic: when someone requires 'self', the
+            * module they get is supposed to be specialized for the *package*
+            * that they live in (so pkg1/foo.js will get 'self' for pkg1,
+            * while pkg2/bar.js will get a 'self' for pkg2). To accomplish
+            * this, we don't give them the real self.js module directly:
+            * instead, we load self.js and invoke its makeSelfModule()
+            * function, passing in the manifest's moduleData, which will
+            * include enough information to create the specialized module.
+            */
+           if (!moduleData) {
+             // we don't know where you live, so we must search for your data
+             // resource://api-utils-api-utils-tests/test-self.js
+             // make a prefix of resource://api-utils-api-utils-data/
+             let doubleslash = basePath.indexOf("//");
+             let prefix = basePath.slice(0, doubleslash+2);
+             let rest = basePath.slice(doubleslash+2);
+             let slash = rest.indexOf("/");
+             prefix = prefix + rest.slice(0, slash);
+             prefix = prefix.slice(0, prefix.lastIndexOf("-")) + "-data/";
+             moduleData = { "dataURIPrefix": prefix };
+             // moduleData also wants mapName and mapSHA256, but they're
+             // currently unused
+           }
+           if (false) // force scanner to copy self-maker.js into the XPI
+             require("./self-maker"); 
+           let makerModData = {uri: self.fs.resolveModule(null, "self-maker")};
+           if (!makerModData.uri)
+             throw new Error("Unable to find self-maker, from "+basePath);
+           let selfMod = loadFromModuleData(makerModData, "self-maker");
+           // selfMod is not cached
+           return selfMod.makeSelfModule(moduleData);
+         }
+
+         if (!moduleData) {
+           // search
+           let path = self.fs.resolveModule(basePath, moduleName);
+           if (!path)
+             throw new Error('Module "' + moduleName + '" not found');
+           moduleData = {uri: path};
+         }
+
+         // Track accesses to this module via its normalized path. This lets
+         // us detect cases where foo.js uses define() with a callback that
+         // wants to return a new value for the 'foo' module, but something
+         // inside that callback (probably in some sub-function) references
+         // 'foo' too early. If this happens, we throw an exception when the
+         // callback finishes. The code for that is in define() below: search
+         // for self.pathAccessed .
+         if (!self.pathAccessed[moduleData.uri]) {
+           self.pathAccessed[moduleData.uri] = 0;
+         }
+         self.pathAccessed[moduleData.uri] += 1;
+
+         if (moduleData.uri in self.modules) {
+           // already loaded: return from cache
+           return self.modules[moduleData.uri];
+         }
+         return loadFromModuleData(moduleData, moduleName); // adds to cache
+       }
+
+       function loadFromModuleData(moduleData, moduleName) {
+         // moduleName is passed solely for error messages: by this point,
+         // everything is controlled by moduleData
+         if (!moduleData.uri) {
+           throw new Error("loadFromModuleData with null URI, from basePath "
+                           +basePath+" importing ("+moduleName+")");
+         }
+         // any manifest-based permission checks have already been done
+         let path = moduleData.uri;
+
+         let moduleContents = self.fs.getFile(path);
+         var sandbox = self.sandboxFactory.createSandbox(moduleContents);
+         self.sandboxes[path] = sandbox;
+         for (let name in self.globals)
+           sandbox.defineProperty(name, self.globals[name]);
+         var api = self._makeApi(path);
+         sandbox.defineProperty('require', api.require);
+         sandbox.defineProperty('define', api.define);
+         if (self.modifyModuleSandbox)
+           self.modifyModuleSandbox(sandbox, moduleContents);
+         /* set up an environment in which module code can use CommonJS
+            patterns like:
+              module.exports = newobj;
+              module.setExports(newobj);
+              if (module.id == "main") stuff();
+              define("async", function() {return newobj});
+          */
+         sandbox.evaluate("var module = {exports: {}};");
+         sandbox.evaluate("module.setExports = function(obj) {module.exports = obj; return obj;};");
+         sandbox.evaluate("var exports = module.exports;");
+         sandbox.evaluate("module.id = '" + path + "';");
+         var preeval_exports = sandbox.getProperty("exports");
+         self.modules[path] = sandbox.getProperty("exports");
+         sandbox.evaluate(moduleContents);
+
+         // We need to duplicate `exports` as Object.freeze throws an exception
+         // on objects coming from another sandbox. Bug 677768.
+         sandbox.evaluate(
+           "if (typeof module.exports === 'object')\n" +
+           "  module.exports = " +
+           "    Object.prototype.isPrototypeOf(module.exports) ? " +
+           "    Object.freeze(module.exports) : " +
+           "    Object.freeze(Object.create(module.exports));");
+
+         var posteval_exports = sandbox.getProperty("module").exports;
+         if (posteval_exports !== preeval_exports) {
+           /* if they used module.exports= or module.setExports(), get
+              the new value now. If they used define(), we must be
+              careful to leave self.modules[path] alone, as it will have
+              been modified in the asyncMain() callback-handling code,
+              fired during sandbox.evaluate(). */
+           if (self.defineUsed[path]) {
+             // you can do one or the other, not both
+             throw new Error("define() was used, so module.exports= and "
+                             + "module.setExports() may not be used: "
+                             + path);
+           }
+           self.modules[path] = posteval_exports;
+         }
+         return self.modules[path];
+       }
+
+       // START support Async module-style require and define calls.
+       // If the only argument to require is a string, then the module that
+       // is represented by that string is fetched for the appropriate context.
+       //
+       // If the first argument is an array, then it will be treated as an array
+       // of dependency string names to fetch. An optional function callback can
+       // be specified to execute when all of those dependencies are available.
+       function asyncRequire(deps, callback) {
+         if (typeof deps === "undefined" && typeof callback === "undefined") {
+           // If we could require() the traceback module here, we could
+           // probably show the source linenumber. But really that should be
+           // part of the stack trace.
+           throw new Error("you must provide a module name when calling require() from "+basePath);
+         } else if (typeof deps === "string" && !callback) {
+           // Just return the module wanted via sync require.
+           return syncRequire(deps);
+         } else {
+           asyncMain(null, basePath, null, deps, callback);
+           return undefined;
+         }
+       }
+
+       // The function that handles definitions of modules. Differs from
+       // require() in that a string for the module should be the first
+       // argument, and the function to execute after dependencies are loaded
+       // should return a value to define the module corresponding to the first
+       // argument's name.
+       function define (name, deps, callback) {
+
+         // Only allow one call to define per module/file.
+         if (self.defineUsed[basePath]) {
+           throw new Error("Only one call to define() allowed per file: " +
+                            basePath);
+         } else {
+           self.defineUsed[basePath] = true;
+         }
+
+         // For anonymous modules, the namePath is the basePath
+         var namePath = basePath,
+             exports = {}, exported;
+
+         // Adjust args if an anonymous module
+         if (typeof name !== 'string') {
+           callback = deps;
+           deps = name;
+           name = null;
+         }
+
+         // If just a define({}) call (no dependencies),
+         // adjust args accordingly.
+         if (!Array.isArray(deps)) {
+           callback = deps;
+           deps = null;
+         }
+
+         // If the callback is not an actual function, it means it already
+         // has the definition of the module as a literal value.
+         if (!deps && callback && typeof callback !== 'function') {
+           self.modules[namePath] = callback;
+           return;
+         }
+
+         // Set the exports value now in case other modules need a handle
+         // on it for cyclical cases.
+         self.modules[namePath] = exports;
+
+         // Load dependencies and call the module's definition function.
+         exported = asyncMain(name, namePath, exports, deps, callback);
+
+         // Assign output of function to name, if exports was not
+         // in play (which asyncMain already figured out).
+         if (exported !== undefined) {
+           if (self.pathAccessed[namePath] > 1) {
+             // Another module already accessed the exported value,
+             // need to throw to avoid nasty circular dependency weirdness
+             throw new Error('Module "' + (name || namePath) + '" cannot use ' +
+                             'return from define to define the module ' +
+                             'after another module has referenced its ' +
+                             'exported value.');
+           } else {
+             self.modules[namePath] = exported;
+           }
+         }
+       }
+
+       // The function that handles the main async module work, for both
+       // require([], function(){}) calls and define calls.
+       // It makes sure all the dependencies exist before calling the
+       // callback function. It will return the result of the callback
+       // function if "exports" is not a dependency.
+       function asyncMain (name, namePath, exports, deps, callback) {
+
+         if (typeof deps === 'function') {
+           callback = deps;
+           deps = null;
+         }
+
+         if (!deps) {
+           deps = [];
+           // The shortened form of the async wrapper for CommonJS modules:
+           // define(function (require, exports, module) {});
+           // require calls could be inside the function, so toString it
+           // and pull out the dependencies.
+
+           // Remove comments from the callback string,
+           // look for require calls, and pull them into the dependencies.
+           // The comment regexp is not very robust, but good enough to
+           // avoid commented out require calls and to find normal, sync
+           // require calls in the function.
+           callback
+               .toString()
+               .replace(commentRegExp, "")
+               .replace(cjsRequireRegExp, function (match, dep) {
+                 deps.push(dep);
+               });
+           // Prepend standard require, exports, and module dependencies
+           // (and in that *exact* order per spec), but only add as many as
+           // was asked for via the callback's function argument length.
+           // In particular, do *not* pass exports if it was not asked for.
+           // By asking for exports as a dependency the rest of this
+           // asyncRequire code assumes then that the return value from the
+           // function should not be used as the exported module value.
+           deps = cjsStandardDeps.slice(0, callback.length).concat(deps);
+         }
+
+         var depModules = [],
+             usesExports = false,
+             exported;
+
+         // Load all the dependencies, with the "require", "exports" and
+         // "module" ones getting special handling to match the traditional
+         // CommonJS sync module expectations.
+         deps.forEach(function (dep) {
+             if (dep === "require") {
+               depModules.push(asyncRequire);
+             } else if (dep === "module") {
+               depModules.push({
+                 id: name
+               });
+             } else if (dep === "exports") {
+               usesExports = true;
+               depModules.push(exports);
+             } else {
+               depModules.push(syncRequire(dep));
+             }
+         });
+
+         // Execute the function.
+         if (callback) {
+           exported = callback.apply(null, depModules);
+         }
+
+         if (exported !== undefined) {
+           if (usesExports) {
+             throw new Error('Inside "' + namePath + '", cannot use exports ' +
+                             'and also return a value from a define ' +
+                             'definition function');
+           } else {
+             return exported;
+           }
+         }
+         return undefined;
+       };
+
+       return {
+         require: asyncRequire,
+         define: define
+       };
+       // END support for Async module-style
+     },
+
+     // This is only really used by unit tests and other
+     // development-related facilities, allowing access to symbols
+     // defined in the global scope of a module.
+     findSandboxForModule: function findSandboxForModule(module) {
+       var path = this.fs.resolveModule(null, module);
+       if (!path)
+         throw new Error('Module "' + module + '" not found');
+       if (!(path in this.sandboxes))
+         this.require(module);
+       if (!(path in this.sandboxes))
+         throw new Error('Internal error: path not in sandboxes: ' +
+                         path);
+       return this.sandboxes[path];
+     },
+
+     require: function require(module, callback) {
+       return (this._makeApi(null).require)(module, callback);
+     },
+
+     runScript: function runScript(options, extraOutput) {
+       if (typeof(options) == 'string')
+         options = {contents: options};
+       options = {__proto__: options};
+       var sandbox = this.sandboxFactory.createSandbox(options);
+       if (extraOutput)
+         extraOutput.sandbox = sandbox;
+       for (let name in this.globals)
+         sandbox.defineProperty(name, this.globals[name]);
+       var api = this._makeApi(null);
+       sandbox.defineProperty('require', api.require);
+       sandbox.defineProperty('define', api.define);
+       return sandbox.evaluate(options);
+     }
+   };
+
+   // this is more of a resolver than a filesystem, but test-securable-module
+   // wants to override the getFile() function to avoid using real URIs
+   exports.CompositeFileSystem = function CompositeFileSystem(options) {
+     // We sort file systems in alphabetical order of a package name.
+     this.fses = options.fses.sort(function(a, b) a.root > b.root);
+     this.uriPrefix = options.uriPrefix;
+     this.name = options.name;
+     this.packages = options.metadata || {};
+   };
+
+   function isRelative(path) path.charAt(0) === "."
+   function isNested(path) ~path.indexOf("/")
+   function normalizePath(path) path.substr(-3) === ".js" ? path : path + ".js"
+   function relatifyPath(path) isRelative(path) ? path : "./" + path
+   function getPackageName(path) path.substr(0, path.indexOf("/"))
+   function getInPackagePath(path) path.substr(path.indexOf("/") + 1)
+   function isRelativeTo(path, base) 0 === path.indexOf(base)
+   function resolveTo(path, base) "." + path.substr(base.length)
+
+   exports.CompositeFileSystem.prototype = {
+     getPackageURI: function getPackageURI(name) {
+       let uri = this.uriPrefix + name + "-lib/";
+       return ios.newURI(uri, null, null).spec;
+     },
+     resolveModule: function resolveModule(base, path) {
+       // If it is relative path we don't need to search anything
+       // as it should be module from the same package.
+       if (isRelative(path)) {
+         // If base is not provided then it's a main module with a relative
+         // path to we use `packageURI` as a base to resolve.
+         base = base || this.getPackageURI(this.name);
+         return this.resolveRelative(base, path);
+       }
+
+       // If path contains only one part then we treat if it as
+       // require(PCKG/{{(package.json).main}}
+       if (!isNested(path))
+         return this.resolveMain(path) || this.searchModule(path);
+
+       // If path contains more then one part than we try to interpret that
+       // as `require(PCKG/module)` first and fall back to search.
+       return this.resolveModuleFromPackage(path) || this.searchModule(path);
+
+     },
+     resolveRelative: function resolveRelative(base, path) {
+        path = normalizePath(path);
+        let uri = ios.newURI(path, null, ios.newURI(base, null, null));
+
+        try {
+          let channel = ios.newChannelFromURI(uri);
+          channel.open().close();
+        } catch (e) {
+          return null;
+        }
+        return uri.spec;
+     },
+     searchModule: function seachModule(path) {
+       for each (let fs in this.fses) {
+         let id = fs.resolveModule(null, path);
+         if (id)
+           return id;
+       }
+       return null;
+     },
+     resolveModuleFromPackage: function resolveModuleFromPackage(path) {
+       let name = getPackageName(path);
+       if (name in this.packages) {
+         let base = this.getPackageURI(name);
+         return this.resolveRelative(base, getInPackagePath(path));
+       }
+       return null;
+     },
+     resolveMain: function resolveMain(name) {
+       if (name in this.packages) {
+         let base = this.getPackageURI(name);
+         let path = relatifyPath(this.packages[name].main || "main");
+
+         // We need to make sure to strip out directory from the main if it
+         // contains "lib" part. Unfortunately if main out of the lib folder
+         // requiring main module will fail as it will be out of the mapped
+         // resource URI.
+         let dirs = this.packages[name].directories;
+         let lib = relatifyPath(dirs ? dirs.lib || "./lib" : "./lib");
+         if (isRelativeTo(path, lib))
+           path = resolveTo(path, lib);
+
+         return this.resolveRelative(base, path);
+       }
+       return null;
+     },
+     getFile: function getFile(path) {
+       return loadFile(path);
+     }
+   };
+
+   exports.LocalFileSystem = function LocalFileSystem(root) {
+     if (root === undefined) {
+       if (!baseURI)
+         throw new Error("Need a root path for module filesystem");
+       root = baseURI;
+     }
+     if (typeof(root) == 'string')
+       root = ios.newURI(root, null, baseURI);
+     if (root instanceof Ci.nsIFile)
+       root = ios.newFileURI(root);
+     if (!(root instanceof Ci.nsIURI))
+       throw new Error('Expected nsIFile, nsIURI, or string for root');
+
+     this.root = root.spec;
+     this._rootURI = root;
+     this._rootURIDir = getRootDir(root.spec);
+   };
+
+   exports.LocalFileSystem.prototype = {
+     resolveModule: function resolveModule(base, path) {
+       path = normalizePath(path);
+
+       var baseURI;
+       if (!base || path.charAt(0) != '.')
+         baseURI = this._rootURI;
+       else
+         baseURI = ios.newURI(base, null, null);
+
+       var newURI = ios.newURI(path, null, baseURI);
+       if (newURI.spec.indexOf(this._rootURIDir) == 0) {
+         var channel = ios.newChannelFromURI(newURI);
+         try {
+           channel.open().close();
+         } catch (e if e.result == Cr.NS_ERROR_FILE_NOT_FOUND) {
+           return null;
+         }
+         return newURI.spec;
+       }
+       return null;
+     },
+     getFile: function getFile(path) {
+       return loadFile(path);
+     }
+   };
+
+   function loadFile(path) {
+     var channel = ios.newChannel(path, null, null);
+     var iStream = channel.open();
+     var ciStream = Cc["@mozilla.org/intl/converter-input-stream;1"].
+       createInstance(Ci.nsIConverterInputStream);
+     var bufLen = 0x8000;
+     ciStream.init(iStream, "UTF-8", bufLen,
+                   Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
+     var chunk = {};
+     var data = "";
+     while (ciStream.readString(bufLen, chunk) > 0)
+       data += chunk.value;
+     ciStream.close();
+     iStream.close();
+     return {contents: data, filename: path};
+   };
+
+   if (global.window) {
+     // We're being loaded in a chrome window, or a web page with
+     // UniversalXPConnect privileges.
+     global.SecurableModule = exports;
+   } else if (global.exports) {
+     // We're being loaded in a SecurableModule.
+     for (let name in exports) {
+       global.exports[name] = exports[name];
+     }
+   } else {
+     // We're being loaded in a JS module.
+     global.EXPORTED_SYMBOLS = [];
+     for (let name in exports) {
+       global.EXPORTED_SYMBOLS.push(name);
+       global[name] = exports[name];
+     }
+   }
+ })(this);
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/self-e10s-adapter.js b/tools/addon-sdk-1.3/packages/api-utils/lib/self-e10s-adapter.js
new file mode 100644
index 0000000..5eeb2a7
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/self-e10s-adapter.js
@@ -0,0 +1,100 @@
+// While this adapter is complete, it most likely isn't very secure,
+// in that it allows the remote addon process to ask for any content
+// on the host filesystem.
+
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+if (this.chrome) {
+  exports.id = chrome.call("self:id");
+  exports.data = {
+    load: function(path) {
+      return chrome.call("self:load", path, new Error().stack);
+    },
+    url: function(path) {
+      return chrome.call("self:url", path, new Error().stack);
+    }
+  };
+} else {
+  // Here we basically have to reimplement the self module.
+
+  let file = require("./file");
+  let url = require("./url");
+  let traceback = require("./traceback");
+
+  let packageData = packaging.options.packageData;
+  let resourcePackages = packaging.options.resourcePackages;
+  let id = packaging.jetpackID;
+
+  function caller(stack, levels) {
+    var e = {
+      stack: stack
+    };
+    let callerInfo = traceback.fromException(e).slice(-2-levels)[0];
+    let info = url.URL(callerInfo.filename);
+    let pkgName = resourcePackages[info.host];
+    // pkgName is "my-package", suitable for lookup in options["packageData"]
+    return pkgName;
+  }
+
+  function getURL(name, stack, level) {
+    let pkgName = caller(stack, level);
+    // packageData[] = "resource://jetpack-JID-PKGNAME-data/"
+    if (pkgName in packageData)
+      return url.URL(name, packageData[pkgName]).toString();
+    throw new Error("No data for package " + pkgName);
+  }
+
+  exports.register = function(addon) {
+    addon.registerCall("self:id", function(name) {
+      return id;
+    });
+    addon.registerCall("self:name", function(name) {
+      return packaging.options.name;
+    });
+    addon.registerCall("self:load", function(name, path, stack) {
+      let data_url = getURL(path, stack, 1);
+      let fn = url.toFilename(data_url);
+      let data = file.read(fn);
+      return data;
+    });
+    addon.registerCall("self:url", function(name, path, stack) {
+      return getURL(path, stack, 1);
+    });
+  }
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/self-maker.js b/tools/addon-sdk-1.3/packages/api-utils/lib/self-maker.js
new file mode 100644
index 0000000..53315a8
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/self-maker.js
@@ -0,0 +1,81 @@
+/* vim:st=2:sts=2:sw=2:
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Brian Warner <warner@mozilla.com>
+ *   Erik Vold <erikvvold@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+let file = require("./file");
+let url = require("./url");
+
+let jid = packaging.jetpackID;
+let name = packaging.options.name;
+
+// Some XPCOM APIs require valid URIs as an argument for certain operations (see
+// `nsILoginManager` for example). This property represents add-on associated
+// unique URI string that can be used for that.
+let uri = "addon:" + jid;
+
+exports.makeSelfModule = function (reqdata) {
+  // a module loaded from URI has called require(MODULE)
+  // URI is like resource://jid0-$JID/$PACKAGE-$SECTION/$SUBDIR/$FILENAME
+  // resource://jid0-abc123/reading-data-lib/main.js
+  // and we want resource://jid0-abc123/reading-data-data/
+
+  var data_url = function(name) {
+    name = name || "";
+    // dataURIPrefix ends with a slash
+    var x = reqdata.dataURIPrefix + name;
+    return x;
+  };
+  var data_load = function(name) {
+    let fn = url.toFilename(data_url(name));
+    return file.read(fn);
+  };
+
+  var self = {
+    id: jid,
+    uri: uri,
+    name: name,
+    version: packaging.options.metadata[name].version,
+    data: {
+      load: data_load,
+      url: data_url
+    }
+  };
+  return self;
+};
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/shims.js b/tools/addon-sdk-1.3/packages/api-utils/lib/shims.js
new file mode 100644
index 0000000..13713b9
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/shims.js
@@ -0,0 +1,53 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// Override the default Iterator function with one that passes
+// a second argument to custom iterator methods that identifies
+// the call as originating from an Iterator function so the custom
+// iterator method can return [key, value] pairs just like default
+// iterators called via the default Iterator function.
+
+"use strict";
+
+Iterator = (function(DefaultIterator) {
+  return function Iterator(obj, keysOnly) {
+    if ("__iterator__" in obj && !keysOnly)
+      return obj.__iterator__.call(obj, false, true);
+    return DefaultIterator(obj, keysOnly);
+  };
+})(Iterator);
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/tab-browser.js b/tools/addon-sdk-1.3/packages/api-utils/lib/tab-browser.js
new file mode 100644
index 0000000..d967e13
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/tab-browser.js
@@ -0,0 +1,761 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *   Dietrich Ayala <dietrich@mozilla.com>
+ *   Felipe Gomes <felipc@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+const {Cc,Ci,Cu} = require("chrome");
+var NetUtil = {};
+Cu.import("resource://gre/modules/NetUtil.jsm", NetUtil);
+NetUtil = NetUtil.NetUtil;
+const errors = require("./errors");
+const windowUtils = require("./window-utils");
+const apiUtils = require("./api-utils");
+const collection = require("./collection");
+
+// TODO: The hard-coding of app-specific info here isn't very nice;
+// ideally such app-specific info should be more decoupled, and the
+// module should be extensible, allowing for support of new apps at
+// runtime, perhaps by inspecting supported packages (e.g. via
+// dynamically-named modules or package-defined extension points).
+
+if (!require("./xul-app").is("Firefox")) {
+  throw new Error([
+    "The tab-browser module currently supports only Firefox.  In the future ",
+    "it will support other applications. Please see ",
+    "https://bugzilla.mozilla.org/show_bug.cgi?id=560716 for more information."
+  ].join(""));
+}
+
+function onBrowserLoad(callback, event) {
+  if (event.target && event.target.defaultView == this) {
+    this.removeEventListener("load", onBrowserLoad, true);
+    try {
+      require("timer").setTimeout(function () {
+        callback(event);
+      }, 10);
+    } catch (e) { console.exception(e); }
+  }
+}
+
+// Utility function to open a new browser window.
+function openBrowserWindow(callback, url) {
+  let ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
+           getService(Ci.nsIWindowWatcher);
+  let urlString = Cc["@mozilla.org/supports-string;1"].
+                  createInstance(Ci.nsISupportsString);
+  urlString.data = url;
+  let window = ww.openWindow(null, "chrome://browser/content/browser.xul",
+                             "_blank", "chrome,all,dialog=no", urlString);
+  if (callback)
+    window.addEventListener("load", onBrowserLoad.bind(window, callback), true);
+
+  return window;
+}
+
+// Open a URL in a new tab
+exports.addTab = function addTab(url, options) {
+  if (!options)
+    options = {};
+  options.url = url;
+
+  options = apiUtils.validateOptions(options, {
+    // TODO: take URL object instead of string (bug 564524)
+    url: {
+      is: ["string"],
+      ok: function (v) !!v,
+      msg: "The url parameter must have be a non-empty string."
+    },
+    inNewWindow: {
+      is: ["undefined", "null", "boolean"]
+    },
+    inBackground: {
+      is: ["undefined", "null", "boolean"]
+    },
+    onLoad: {
+      is: ["undefined", "null", "function"]
+    },
+    isPinned: {
+      is: ["undefined", "boolean"]
+    }
+  });
+
+  var wm = Cc["@mozilla.org/appshell/window-mediator;1"]
+           .getService(Ci.nsIWindowMediator);
+  var win = wm.getMostRecentWindow("navigator:browser");
+  if (!win || options.inNewWindow) {
+    openBrowserWindow(function(e) {
+      if(options.isPinned) {
+        //get the active tab in the recently created window
+        let mainWindow = e.target.defaultView;
+        mainWindow.gBrowser.pinTab(mainWindow.gBrowser.selectedTab);
+      }
+      require("./errors").catchAndLog(function(e) options.onLoad(e))(e);
+    }, options.url);
+  } else {
+    let tab = win.gBrowser.addTab(options.url);
+    if (!options.inBackground)
+      win.gBrowser.selectedTab = tab;
+    if (options.onLoad) {
+      let tabBrowser = win.gBrowser.getBrowserForTab(tab);
+      tabBrowser.addEventListener("load", function onLoad(e) {
+        if (e.target.defaultView.content.location == "about:blank")
+          return;
+        // remove event handler from addTab - don't want notified
+        // for subsequent loads in same tab.
+        tabBrowser.removeEventListener("load", onLoad, true);
+        require("./errors").catchAndLog(function(e) options.onLoad(e))(e);
+      }, true);
+    }
+  }
+}
+
+// Iterate over a window's tabbrowsers
+function tabBrowserIterator(window) {
+  var browsers = window.document.querySelectorAll("tabbrowser");
+  for (var i = 0; i < browsers.length; i++)
+    yield browsers[i];
+}
+
+// Iterate over a tabbrowser's tabs
+function tabIterator(tabbrowser) {
+  var tabs = tabbrowser.tabContainer;
+  for (var i = 0; i < tabs.children.length; i++) {
+    yield tabs.children[i];
+  }
+}
+
+// Tracker for all tabbrowsers across all windows,
+// or a single tabbrowser if the window is given.
+function Tracker(delegate, window) {
+  this._delegate = delegate;
+  this._browsers = [];
+  this._window = window;
+  this._windowTracker = new windowUtils.WindowTracker(this);
+
+  require("./unload").ensure(this);
+}
+Tracker.prototype = {
+  __iterator__: function __iterator__() {
+    for (var i = 0; i < this._browsers.length; i++)
+      yield this._browsers[i];
+  },
+  get: function get(index) {
+    return this._browsers[index];
+  },
+  onTrack: function onTrack(window) {
+    if (this._window && window != this._window)
+      return;
+
+    for (let browser in tabBrowserIterator(window))
+      this._browsers.push(browser);
+    if (this._delegate)
+      for (let browser in tabBrowserIterator(window))
+        this._delegate.onTrack(browser);
+  },
+  onUntrack: function onUntrack(window) {
+    if (this._window && window != this._window)
+      return;
+
+    for (let browser in tabBrowserIterator(window)) {
+      let index = this._browsers.indexOf(browser);
+      if (index != -1)
+        this._browsers.splice(index, 1);
+      else
+        console.error("internal error: browser tab not found");
+    }
+    if (this._delegate)
+      for (let browser in tabBrowserIterator(window))
+        this._delegate.onUntrack(browser);
+  },
+  get length() {
+    return this._browsers.length;
+  },
+  unload: function unload() {
+    this._windowTracker.unload();
+  }
+};
+exports.Tracker = apiUtils.publicConstructor(Tracker);
+
+// Tracker for all tabs across all windows,
+// or a single window if it's given.
+function TabTracker(delegate, window) {
+  this._delegate = delegate;
+  this._tabs = [];
+  this._tracker = new Tracker(this, window);
+  require("./unload").ensure(this);
+}
+TabTracker.prototype = {
+  _TAB_EVENTS: ["TabOpen", "TabClose"],
+  _safeTrackTab: function safeTrackTab(tab) {
+    this._tabs.push(tab);
+    try {
+      this._delegate.onTrack(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  _safeUntrackTab: function safeUntrackTab(tab) {
+    var index = this._tabs.indexOf(tab);
+    if (index == -1)
+      console.error("internal error: tab not found");
+    this._tabs.splice(index, 1);
+    try {
+      this._delegate.onUntrack(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  handleEvent: function handleEvent(event) {
+    switch (event.type) {
+    case "TabOpen":
+      this._safeTrackTab(event.target);
+      break;
+    case "TabClose":
+      this._safeUntrackTab(event.target);
+      break;
+    default:
+      throw new Error("internal error: unknown event type: " +
+                      event.type);
+    }
+  },
+  onTrack: function onTrack(tabbrowser) {
+    for (let tab in tabIterator(tabbrowser))
+      this._safeTrackTab(tab);
+    var self = this;
+    this._TAB_EVENTS.forEach(
+      function(eventName) {
+        tabbrowser.tabContainer.addEventListener(eventName, self, true);
+      });
+  },
+  onUntrack: function onUntrack(tabbrowser) {
+    for (let tab in tabIterator(tabbrowser))
+      this._safeUntrackTab(tab);
+    var self = this;
+    this._TAB_EVENTS.forEach(
+      function(eventName) {
+        tabbrowser.tabContainer.removeEventListener(eventName, self, true);
+      });
+  },
+  unload: function unload() {
+    this._tracker.unload();
+  }
+};
+exports.TabTracker = apiUtils.publicConstructor(TabTracker);
+
+exports.whenContentLoaded = function whenContentLoaded(callback) {
+  var cb = require("./errors").catchAndLog(function eventHandler(event) {
+    if (event.target && event.target.defaultView)
+      callback(event.target.defaultView);
+  });
+
+  var tracker = new Tracker({
+    onTrack: function(tabBrowser) {
+      tabBrowser.addEventListener("DOMContentLoaded", cb, false);
+    },
+    onUntrack: function(tabBrowser) {
+      tabBrowser.removeEventListener("DOMContentLoaded", cb, false);
+    }
+  });
+
+  return tracker;
+};
+
+exports.__defineGetter__("activeTab", function() {
+  const wm = Cc["@mozilla.org/appshell/window-mediator;1"].
+             getService(Ci.nsIWindowMediator);
+  let mainWindow = wm.getMostRecentWindow("navigator:browser");
+  return mainWindow.gBrowser.selectedTab;
+});
+
+/******************* TabModule *********************/
+
+// Supported tab events
+const events = [
+  "onActivate",
+  "onDeactivate",
+  "onOpen",
+  "onClose",
+  "onReady",
+  "onLoad",
+  "onPaint"
+];
+exports.tabEvents = events;
+
+/**
+ * TabModule
+ *
+ * Constructor for a module that implements the tabs API
+ */
+let TabModule = exports.TabModule = function TabModule(window) {
+  let self = this;
+  /**
+   * Tab
+   *
+   * Safe object representing a tab.
+   */
+  let tabConstructor = apiUtils.publicConstructor(function(element) {
+    if (!element)
+      throw new Error("no tab element.");
+    let win = element.ownerDocument.defaultView;
+    if (!win)
+      throw new Error("element has no window.");
+    if (window && win != window)
+      throw new Error("module's window and element's window don't match.");
+    let browser = win.gBrowser.getBrowserForTab(element);
+
+    this.__defineGetter__("title", function() browser.contentDocument.title);
+    this.__defineGetter__("location", function() browser.contentDocument.location);
+    this.__defineSetter__("location", function(val) browser.contentDocument.location = val);
+    this.__defineGetter__("contentWindow", function() browser.contentWindow);
+    this.__defineGetter__("contentDocument", function() browser.contentDocument);
+    this.__defineGetter__("favicon", function() {
+      let pageURI = NetUtil.newURI(browser.contentDocument.location);
+      let fs = Cc["@mozilla.org/browser/favicon-service;1"].
+               getService(Ci.nsIFaviconService);
+      let faviconURL;
+      try {
+        let faviconURI = fs.getFaviconForPage(pageURI);
+        faviconURL = fs.getFaviconDataAsDataURL(faviconURI);
+      } catch(ex) {
+        let data = getChromeURLContents("chrome://mozapps/skin/places/defaultFavicon.png");
+        let encoded = browser.contentWindow.btoa(data);
+        faviconURL = "data:image/png;base64," + encoded;
+      }
+      return faviconURL;
+    });
+    this.__defineGetter__("style", function() null); // TODO
+    this.__defineGetter__("index", function() win.gBrowser.getBrowserIndexForDocument(browser.contentDocument));
+    this.__defineGetter__("thumbnail", function() getThumbnailCanvasForTab(element, browser.contentWindow));
+
+    this.close = function() win.gBrowser.removeTab(element);
+    this.move = function(index) {
+      win.gBrowser.moveTabTo(element, index);
+    };
+
+    this.__defineGetter__("isPinned", function() element.pinned);
+    this.pin = function() win.gBrowser.pinTab(element);
+    this.unpin = function() win.gBrowser.unpinTab(element);
+
+    // Set up the event handlers
+    let tab = this;
+    events.filter(function(e) e != "onOpen").forEach(function(e) {
+      // create a collection for each event
+      collection.addCollectionProperty(tab, e);
+      // make tabs setter for each event, for adding via property assignment
+      tab.__defineSetter__(e, function(val) tab[e].add(val));
+    });
+
+    // listen for events, filtered on this tab
+    eventsTabDelegate.addTabDelegate(this);
+  });
+
+  /**
+   * tabs.activeTab
+   */
+  this.__defineGetter__("activeTab", function() {
+    try {
+      return window ? tabConstructor(window.gBrowser.selectedTab)
+                    : tabConstructor(exports.activeTab);
+    }
+    catch (e) { }
+    return null;
+  });
+  this.__defineSetter__("activeTab", function(tab) {
+    let [tabElement, win] = getElementAndWindowForTab(tab, window);
+    if (tabElement) {
+      // set as active tab
+      win.gBrowser.selectedTab = tabElement;
+      // focus the window
+      win.focus();
+    }
+  });
+
+  this.open = function TM_open(options) {
+    open(options, tabConstructor, window);
+  }
+
+  // Set up the event handlers
+  events.forEach(function(eventHandler) {
+    // create a collection for each event
+    collection.addCollectionProperty(self, eventHandler);
+    // make tabs setter for each event, for adding via property assignment
+    self.__defineSetter__(eventHandler, function(val) self[eventHandler].add(val));
+  });
+
+  // Tracker that listens for tab events, and proxies
+  // them to registered event listeners.
+  let eventsTabDelegate = {
+    selectedTab: null,
+    tabs: [],
+    addTabDelegate: function TETT_addTabDelegate(tabObj) {
+      this.tabs.push(tabObj);
+    },
+    pushTabEvent: function TETT_pushTabEvent(event, tab) {
+      for (let callback in self[event]) {
+        require("./errors").catchAndLog(function(tab) {
+          callback(new tabConstructor(tab));
+        })(tab);
+      }
+
+      if (event != "onOpen") {
+        this.tabs.forEach(function(tabObj) {
+          if (tabObj[event].length) {
+            let [tabEl,] = getElementAndWindowForTab(tabObj, window);
+            if (tabEl == tab) {
+              for (let callback in tabObj[event])
+                require("./errors").catchAndLog(function() callback())();
+            }
+          }
+          // if being closed, remove the tab object from the cache
+          // of tabs to notify about events.
+          if (event == "onClose")
+            this.tabs.splice(this.tabs.indexOf(tabObj), 1);
+        }, this);
+      }
+    },
+    unload: function() {
+      this.selectedTab = null;
+      this.tabs.splice(0);
+    }
+  };
+  require("./unload").ensure(eventsTabDelegate);
+
+  let eventsTabTracker = new ModuleTabTracker({
+    onTrack: function TETT_onTrack(tab) {
+      eventsTabDelegate.pushTabEvent("onOpen", tab);
+    },
+    onUntrack: function TETT_onUntrack(tab) {
+      eventsTabDelegate.pushTabEvent("onClose", tab);
+    },
+    onSelect: function TETT_onSelect(tab) {
+      if (eventsTabDelegate.selectedTab)
+        eventsTabDelegate.pushTabEvent("onDeactivate", tab);
+
+      eventsTabDelegate.selectedTab = new tabConstructor(tab);
+
+      eventsTabDelegate.pushTabEvent("onActivate", tab);
+    },
+    onReady: function TETT_onReady(tab) {
+      eventsTabDelegate.pushTabEvent("onReady", tab);
+    },
+    onLoad: function TETT_onLoad(tab) {
+      eventsTabDelegate.pushTabEvent("onLoad", tab);
+    },
+    onPaint: function TETT_onPaint(tab) {
+      eventsTabDelegate.pushTabEvent("onPaint", tab);
+    }
+  }, window);
+  require("./unload").ensure(eventsTabTracker);
+
+  // Iterator for all tabs
+  this.__iterator__ = function tabsIterator() {
+    for (let i = 0; i < eventsTabTracker._tabs.length; i++)
+      yield tabConstructor(eventsTabTracker._tabs[i]);
+  }
+
+  this.__defineGetter__("length", function() eventsTabTracker._tabs.length);
+
+  // Cleanup when unloaded
+  this.unload = function TM_unload() {
+    // Unregister tabs event listeners
+    events.forEach(function(e) self[e] = []);
+  }
+  require("./unload").ensure(this);
+
+} // End of TabModule constructor
+
+/**
+ * tabs.open - open a URL in a new tab
+ */
+function open(options, tabConstructor, window) {
+  if (typeof options === "string")
+    options = { url: options };
+
+  options = apiUtils.validateOptions(options, {
+    url: {
+      is: ["string"]
+    },
+    inNewWindow: {
+      is: ["undefined", "boolean"]
+    },
+    inBackground: {
+      is: ["undefined", "boolean"]
+    },
+    isPinned: {
+      is: ["undefined", "boolean"]
+    },
+    onOpen: {
+      is: ["undefined", "function"]
+    }
+  });
+
+  if (window)
+    options.inNewWindow = false;
+
+  let win = window || require("./window-utils").activeBrowserWindow;
+
+  if (!win || options.inNewWindow)
+    openURLInNewWindow(options, tabConstructor);
+  else
+    openURLInNewTab(options, win, tabConstructor);
+}
+
+function openURLInNewWindow(options, tabConstructor) {
+  let addTabOptions = {
+    inNewWindow: true
+  };
+  if (options.onOpen) {
+    addTabOptions.onLoad = function(e) {
+      let win = e.target.defaultView;
+      let tabEl = win.gBrowser.tabContainer.childNodes[0];
+      let tabBrowser = win.gBrowser.getBrowserForTab(tabEl);
+      tabBrowser.addEventListener("load", function onLoad(e) {
+        tabBrowser.removeEventListener("load", onLoad, true);
+        let tab = tabConstructor(tabEl);
+        require("./errors").catchAndLog(function(e) options.onOpen(e))(tab);
+      }, true);
+    };
+  }
+  if (options.isPinned) {
+    addTabOptions.isPinned = true;
+  }
+  exports.addTab(options.url.toString(), addTabOptions);
+}
+
+function openURLInNewTab(options, window, tabConstructor) {
+  window.focus();
+  let tabEl = window.gBrowser.addTab(options.url.toString());
+  if (!options.inBackground)
+    window.gBrowser.selectedTab = tabEl;
+  if (options.isPinned)
+    window.gBrowser.pinTab(tabEl);
+  if (options.onOpen) {
+    let tabBrowser = window.gBrowser.getBrowserForTab(tabEl);
+    tabBrowser.addEventListener("load", function onLoad(e) {
+      // remove event handler from addTab - don't want to be notified
+      // for subsequent loads in same tab.
+      tabBrowser.removeEventListener("load", onLoad, true);
+      let tab = tabConstructor(tabEl);
+      require("./timer").setTimeout(function() {
+        require("./errors").catchAndLog(function(tab) options.onOpen(tab))(tab);
+      }, 10);
+    }, true);
+  }
+}
+
+function getElementAndWindowForTab(tabObj, window) {
+  // iterate over open windows, or use single window if provided
+  let windowIterator = window ? function() { yield window; }
+                              : require("./window-utils").windowIterator;
+  for (let win in windowIterator()) {
+    if (win.gBrowser) {
+      // find the tab element at tab.index
+      let index = win.gBrowser.getBrowserIndexForDocument(tabObj.contentDocument);
+      if (index > -1)
+        return [win.gBrowser.tabContainer.getItemAtIndex(index), win];
+    }
+  }
+  return [null, null];
+}
+
+// Tracker for all tabs across all windows
+// This is tab-browser.TabTracker, but with
+// support for additional events added.
+function ModuleTabTracker(delegate, window) {
+  this._delegate = delegate;
+  this._tabs = [];
+  this._tracker = new Tracker(this, window);
+  require("./unload").ensure(this);
+}
+ModuleTabTracker.prototype = {
+  _TAB_EVENTS: ["TabOpen", "TabClose", "TabSelect", "DOMContentLoaded",
+                "load", "MozAfterPaint"],
+  _safeTrackTab: function safeTrackTab(tab) {
+    tab.addEventListener("load", this, false);
+    tab.linkedBrowser.addEventListener("MozAfterPaint", this, false);
+    this._tabs.push(tab);
+    try {
+      this._delegate.onTrack(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  _safeUntrackTab: function safeUntrackTab(tab) {
+    tab.removeEventListener("load", this, false);
+    tab.linkedBrowser.removeEventListener("MozAfterPaint", this, false);
+    var index = this._tabs.indexOf(tab);
+    if (index == -1)
+      throw new Error("internal error: tab not found");
+    this._tabs.splice(index, 1);
+    try {
+      this._delegate.onUntrack(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  _safeSelectTab: function safeSelectTab(tab) {
+    var index = this._tabs.indexOf(tab);
+    if (index == -1)
+      console.error("internal error: tab not found");
+    try {
+      if (this._delegate.onSelect)
+        this._delegate.onSelect(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  _safeDOMContentLoaded: function safeDOMContentLoaded(event) {
+    let tabBrowser = event.currentTarget;
+    let tabBrowserIndex = tabBrowser.getBrowserIndexForDocument(event.target);
+    // TODO: I'm seeing this when loading data url images
+    if (tabBrowserIndex == -1)
+      return;
+    let tab = tabBrowser.tabContainer.getItemAtIndex(tabBrowserIndex);
+    let index = this._tabs.indexOf(tab);
+    if (index == -1)
+      console.error("internal error: tab not found");
+    try {
+      if (this._delegate.onReady)
+        this._delegate.onReady(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  _safeLoad: function safeLoad(event) {
+    let tab = event.target;
+    let index = this._tabs.indexOf(tab);
+    if (index == -1)
+      console.error("internal error: tab not found");
+    try {
+      if (this._delegate.onLoad)
+        this._delegate.onLoad(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  _safeMozAfterPaint: function safeMozAfterPaint(event) {
+    let win = event.currentTarget.ownerDocument.defaultView;
+    let tabIndex = win.gBrowser.getBrowserIndexForDocument(event.target.document);
+    if (tabIndex == -1)
+      return;
+    let tab = win.gBrowser.tabContainer.getItemAtIndex(tabIndex);
+    let index = this._tabs.indexOf(tab);
+    if (index == -1)
+      console.error("internal error: tab not found");
+    try {
+      if (this._delegate.onPaint)
+        this._delegate.onPaint(tab);
+    } catch (e) {
+      console.exception(e);
+    }
+  },
+  handleEvent: function handleEvent(event) {
+    switch (event.type) {
+    case "TabOpen":
+      this._safeTrackTab(event.target);
+      break;
+    case "TabClose":
+      this._safeUntrackTab(event.target);
+      break;
+    case "TabSelect":
+      this._safeSelectTab(event.target);
+      break;
+    case "DOMContentLoaded":
+      this._safeDOMContentLoaded(event);
+      break;
+    case "load":
+      this._safeLoad(event);
+      break;
+    case "MozAfterPaint":
+      this._safeMozAfterPaint(event);
+      break;
+    default:
+      throw new Error("internal error: unknown event type: " +
+                      event.type);
+    }
+  },
+  onTrack: function onTrack(tabbrowser) {
+    for (let tab in tabIterator(tabbrowser))
+      this._safeTrackTab(tab);
+    tabbrowser.tabContainer.addEventListener("TabOpen", this, false);
+    tabbrowser.tabContainer.addEventListener("TabClose", this, false);
+    tabbrowser.tabContainer.addEventListener("TabSelect", this, false);
+    tabbrowser.ownerDocument.defaultView.gBrowser.addEventListener("DOMContentLoaded", this, false);
+  },
+  onUntrack: function onUntrack(tabbrowser) {
+    for (let tab in tabIterator(tabbrowser))
+      this._safeUntrackTab(tab);
+    tabbrowser.tabContainer.removeEventListener("TabOpen", this, false);
+    tabbrowser.tabContainer.removeEventListener("TabClose", this, false);
+    tabbrowser.tabContainer.removeEventListener("TabSelect", this, false);
+    tabbrowser.ownerDocument.defaultView.gBrowser.removeEventListener("DOMContentLoaded", this, false);
+  },
+  unload: function unload() {
+    this._tracker.unload();
+  }
+};
+
+// Utility to get a thumbnail canvas from a tab object
+function getThumbnailCanvasForTab(tabEl, window) {
+  var thumbnail = window.document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
+  thumbnail.mozOpaque = true;
+  var window = tabEl.linkedBrowser.contentWindow;
+  thumbnail.width = Math.ceil(window.screen.availWidth / 5.75);
+  var aspectRatio = 0.5625; // 16:9
+  thumbnail.height = Math.round(thumbnail.width * aspectRatio);
+  var ctx = thumbnail.getContext("2d");
+  var snippetWidth = window.innerWidth * .6;
+  var scale = thumbnail.width / snippetWidth;
+  ctx.scale(scale, scale);
+  ctx.drawWindow(window, window.scrollX, window.scrollY, snippetWidth, snippetWidth * aspectRatio, "rgb(255,255,255)");
+  return thumbnail;
+}
+
+// Utility to return the contents of the target of a chrome URL
+function getChromeURLContents(chromeURL) {
+  let io = Cc["@mozilla.org/network/io-service;1"].
+           getService(Ci.nsIIOService);
+  let channel = io.newChannel(chromeURL, null, null);
+  let input = channel.open();
+  let stream = Cc["@mozilla.org/binaryinputstream;1"].
+               createInstance(Ci.nsIBinaryInputStream); 
+  stream.setInputStream(input);
+  let str = stream.readBytes(input.available());
+  stream.close();
+  input.close();
+  return str;
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/events.js b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/events.js
new file mode 100644
index 0000000..96309bb
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/events.js
@@ -0,0 +1,56 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const ON_PREFIX = "on";
+const TAB_PREFIX = "Tab";
+
+const EVENTS = {
+  ready: "DOMContentLoaded",
+  open: "TabOpen",
+  close: "TabClose",
+  activate: "TabSelect",
+  deactivate: null
+}
+exports.EVENTS = EVENTS;
+
+Object.keys(EVENTS).forEach(function(name) {
+  EVENTS[name] = {
+    name: name,
+    listener: ON_PREFIX + name.charAt(0).toUpperCase() + name.substr(1),
+    dom: EVENTS[name]
+  }
+});
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/observer.js b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/observer.js
new file mode 100644
index 0000000..f679917
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/observer.js
@@ -0,0 +1,126 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { EventEmitterTrait: EventEmitter } = require("../events");
+const { DOMEventAssembler } = require("../events/assembler");
+const { Trait } = require("../light-traits");
+const { getActiveTab, getTabs, getTabContainers } = require("./utils");
+const { browserWindowIterator, isBrowser } = require("../window-utils");
+const { observer: windowObserver } = require("../windows/observer");
+
+const EVENTS = {
+  "TabOpen": "open",
+  "TabClose": "close",
+  "TabSelect": "select",
+  "TabMove": "move",
+  "TabPinned": "pin",
+  "TabUnpinned": "unpin"
+};
+
+
+// Event emitter objects used to register listeners and emit events on them
+// when they occur.
+const observer = Trait.compose(DOMEventAssembler, EventEmitter).create({
+  /**
+   * Method is implemented by `EventEmitter` and is used just for emitting
+   * events on registered listeners.
+   */
+  _emit: Trait.required,
+  /**
+   * Events that are supported and emitted by the module.
+   */
+  supportedEventsTypes: Object.keys(EVENTS),
+  /**
+   * Function handles all the supported events on all the windows that are
+   * observed. Method is used to proxy events to the listeners registered on
+   * this event emitter.
+   * @param {Event} event
+   *    Keyboard event being emitted.
+   */
+  handleEvent: function handleEvent(event) {
+    this._emit(EVENTS[event.type], event.target, event);
+  }
+});
+
+// Currently gecko does not dispatches any event on the previously selected
+// tab before / after "TabSelect" is dispatched. In order to work around this
+// limitation we keep track of selected tab and emit "deactivate" event with
+// that before emitting "activate" on selected tab.
+var selectedTab = null;
+function onTabSelect(tab) {
+  if (selectedTab !== tab) {
+    if (selectedTab) observer._emit("deactivate", selectedTab);
+    if (tab) observer._emit("activate", selectedTab = tab);
+  }
+};
+observer.on("select", onTabSelect);
+
+// We also observe opening / closing windows in order to add / remove it's
+// containers to the observed list.
+function onWindowOpen(chromeWindow) {
+  if (!isBrowser(chromeWindow)) return; // Ignore if it's not a browser window.
+  getTabContainers(chromeWindow).forEach(function (container) {
+    observer.observe(container);
+  });
+}
+windowObserver.on("open", onWindowOpen);
+
+function onWindowClose(chromeWindow) {
+  if (!isBrowser(chromeWindow)) return; // Ignore if it's not a browser window.
+  getTabContainers(chromeWindow).forEach(function (container) {
+    observer.ignore(container);
+  });
+}
+windowObserver.on("close", onWindowClose);
+
+
+// Currently gecko does not dispatches "TabSelect" events when different
+// window gets activated. To work around this limitation we emulate "select"
+// event for this case.
+windowObserver.on("activate", function onWindowActivate(chromeWindow) {
+  if (!isBrowser(chromeWindow)) return; // Ignore if it's not a browser window.
+  observer._emit("select", getActiveTab(chromeWindow));
+});
+
+// We should synchronize state, since probably we already have at least one
+// window open.
+for each (let window in browserWindowIterator()) onWindowOpen(window);
+
+exports.observer = observer;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/tab.js b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/tab.js
new file mode 100644
index 0000000..17e2ff6
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/tab.js
@@ -0,0 +1,297 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { Ci } = require('chrome');
+const { Trait } = require("../traits");
+const { EventEmitter } = require("../events");
+const { validateOptions } = require("../api-utils");
+const { Enqueued } = require("../utils/function");
+const { EVENTS } = require("./events");
+const { getThumbnailURIForWindow } = require("../utils/thumbnail");
+const { getFaviconURIForLocation } = require("../utils/data");
+
+
+
+// Array of the inner instances of all the wrapped tabs.
+const TABS = [];
+
+/**
+ * Trait used to create tab wrappers.
+ */
+const TabTrait = Trait.compose(EventEmitter, {
+  on: Trait.required,
+  _emit: Trait.required,
+  /**
+   * Tab DOM element that is being wrapped.
+   */
+  _tab: null,
+  /**
+   * Window wrapper whose tab this object represents.
+   */
+  window: null,
+  constructor: function Tab(options) {
+    this._onReady = this._onReady.bind(this);
+    this._tab = options.tab;
+    let window = this.window = options.window;
+    // Setting event listener if was passed.
+    for each (let type in EVENTS) {
+      let listener = options[type.listener];
+      if (listener)
+        this.on(type.name, options[type.listener]);
+      if ('ready' != type.name) // window spreads this event.
+        window.tabs.on(type.name, this._onEvent.bind(this, type.name));
+    }
+
+    this.on(EVENTS.close.name, this.destroy.bind(this));
+    this._browser.addEventListener(EVENTS.ready.dom, this._onReady, true);
+
+    if (options.isPinned)
+      this.pin();
+
+    // Since we will have to identify tabs by a DOM elements facade function
+    // is used as constructor that collects all the instances and makes sure
+    // that they more then one wrapper is not created per tab.
+    return this;
+  },
+  destroy: function destroy() {
+    for each (let type in EVENTS)
+      this._removeAllListeners(type.name);
+    this._browser.removeEventListener(EVENTS.ready.dom, this._onReady,
+                                            true);
+  },
+
+  /**
+   * Internal listener that emits public event 'ready' when the page of this
+   * tab is loaded.
+   */
+  _onReady: function _onReady(event) {
+    // IFrames events will bubble so we need to ignore those.
+    if (event.target == this._contentDocument)
+      this._emit(EVENTS.ready.name, this._public);
+  },
+  /**
+   * Internal tab event router. Window will emit tab related events for all it's
+   * tabs, this listener will propagate all the events for this tab to it's
+   * listeners.
+   */
+  _onEvent: function _onEvent(type, tab) {
+    if (tab == this._public)
+      this._emit(type, tab);
+  },
+  /**
+   * Browser DOM element where page of this tab is currently loaded.
+   */
+  get _browser() this._window.gBrowser.getBrowserForTab(this._tab),
+  /**
+   * Window DOM element containing this tab.
+   */
+  get _window() this._tab.ownerDocument.defaultView,
+  /**
+   * Document object of the page that is currently loaded in this tab.
+   */
+  get _contentDocument() this._browser.contentDocument,
+  /**
+   * Window object of the page that is currently loaded in this tab.
+   */
+  get _contentWindow() this._browser.contentWindow,
+
+  /**
+   * The title of the page currently loaded in the tab.
+   * Changing this property changes an actual title.
+   * @type {String}
+   */
+  get title() this._contentDocument.title,
+  set title(value) this._contentDocument.title = String(value),
+  /**
+   * Location of the page currently loaded in this tab.
+   * Changing this property will loads page under under the specified location.
+   * @type {String}
+   */
+  get url() String(this._browser.currentURI.spec),
+  set url(value) this._changeLocation(String(value)),
+  // "TabOpen" event is fired when it's still "about:blank" is loaded in the
+  // changing `location` property of the `contentDocument` has no effect since
+  // seems to be either ignored or overridden by internal listener, there for
+  // location change is enqueued for the next turn of event loop.
+  _changeLocation: Enqueued(function(url) this._browser.loadURI(url)),
+  /**
+   * URI of the favicon for the page currently loaded in this tab.
+   * @type {String}
+   */
+  get favicon() getFaviconURIForLocation(this.url),
+  /**
+   * The CSS style for the tab
+   */
+  get style() null, // TODO
+  /**
+   * The index of the tab relative to other tabs in the application window.
+   * Changing this property will change order of the actual position of the tab.
+   * @type {Number}
+   */
+  get index()
+    this._window.gBrowser.getBrowserIndexForDocument(this._contentDocument),
+  set index(value) this._window.gBrowser.moveTabTo(this._tab, value),
+  /**
+   * Thumbnail data URI of the page currently loaded in this tab.
+   * @type {String}
+   */
+  getThumbnail: function getThumbnail()
+    getThumbnailURIForWindow(this._contentWindow),
+  /**
+   * Whether or not tab is pinned (Is an app-tab).
+   * @type {Boolean}
+   */
+  get isPinned() this._tab.pinned,
+  pin: function pin() {
+    this._window.gBrowser.pinTab(this._tab);
+  },
+  unpin: function unpin() {
+    this._window.gBrowser.unpinTab(this._tab);
+  },
+  
+  /**
+   * Create a worker for this tab, first argument is options given to Worker.
+   * @type {Worker}
+   */
+  attach: function attach(options) {
+    let { Worker } = require("../content/worker");
+    options.window = this._contentWindow;
+    let worker = Worker(options);
+    worker.once("detach", function detach() {
+      worker.destroy();
+    });
+    return worker;
+  },
+  
+  /**
+   * Make this tab active.
+   * Please note: That this function is called synchronous since in E10S that
+   * will be the case. Besides this function is called from a constructor where
+   * we would like to return instance before firing a 'TabActivated' event.
+   */
+  activate: Enqueued(function activate() {
+    if (this._window) // Ignore if window is closed by the time this is invoked.
+      this._window.gBrowser.selectedTab = this._tab;
+  }),
+  /**
+   * Close the tab
+   */
+  close: function close(callback) {
+    if (callback)
+      this.once(EVENTS.close.name, callback);
+    this._window.gBrowser.removeTab(this._tab);
+  },
+  /**
+   * Reload the tab
+   */
+  reload: function reload() {
+    this._window.gBrowser.reloadTab(this._tab);
+  }
+});
+
+function Tab(options) {
+  let chromeTab = options.tab;
+  for each (let tab in TABS) {
+    if (chromeTab == tab._tab)
+      return tab._public;
+  }
+  let tab = TabTrait(options);
+  TABS.push(tab);
+  return tab._public;
+}
+Tab.prototype = TabTrait.prototype;
+exports.Tab = Tab;
+
+function Options(options) {
+  if ("string" === typeof options)
+    options = { url: options };
+
+  return validateOptions(options, {
+    url: { is: ["string"] },
+    inBackground: { is: ["undefined", "boolean"] },
+    isPinned: { is: ["undefined", "boolean"] },
+    onOpen: { is: ["undefined", "function"] },
+    onClose: { is: ["undefined", "function"] },
+    onReady: { is: ["undefined", "function"] },
+    onActivate: { is: ["undefined", "function"] },
+    onDeactivate: { is: ["undefined", "function"] }
+  });
+}
+exports.Options = Options;
+
+
+exports.getTabForWindow = function (win) {
+  // Get browser window
+  let topWindow = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                     .getInterface(Ci.nsIWebNavigation)
+                     .QueryInterface(Ci.nsIDocShellTreeItem)
+                     .rootTreeItem
+                     .QueryInterface(Ci.nsIInterfaceRequestor)
+                     .getInterface(Ci.nsIDOMWindow);
+  if (!topWindow.gBrowser) return null;
+  
+  // Get top window object, in case we are in a content iframe
+  let topContentWindow;
+  try {
+    topContentWindow = win.top;
+  } catch(e) {
+    // It may throw if win is not a valid content window
+    return null;
+  }
+  
+  function getWindowID(obj) {
+    return obj.QueryInterface(Ci.nsIInterfaceRequestor)
+              .getInterface(Ci.nsIDOMWindowUtils)
+              .currentInnerWindowID;
+  }
+  
+  // Search for related Tab
+  let topWindowId = getWindowID(topContentWindow);
+  for (let i = 0; i < topWindow.gBrowser.browsers.length; i++) {
+    let w = topWindow.gBrowser.browsers[i].contentWindow;
+    if (getWindowID(w) == topWindowId) {
+      return Tab({
+        // TODO: api-utils should not depend on addon-kit!
+        window: require("addon-kit/windows").BrowserWindow({ window: topWindow }),
+        tab: topWindow.gBrowser.tabs[i]
+      });
+    }
+  }
+  
+  // We were unable to find the related tab!
+  return null;
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/utils.js b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/utils.js
new file mode 100644
index 0000000..030956c
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/tabs/utils.js
@@ -0,0 +1,87 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+function getTabContainer(tabBrowser) {
+  return tabBrowser.tabContainer;
+}
+exports.getTabContainer = getTabContainer;
+
+function getTabBrowsers(window) {
+  return Array.slice(window.document.getElementsByTagName("tabbrowser"));
+}
+exports.getTabBrowsers = getTabBrowsers;
+
+function getTabContainers(window) {
+  return getTabBrowsers(window).map(getTabContainer);
+}
+exports.getTabContainers = getTabContainers;
+
+function getTabs(window) {
+  return getTabContainers(window).reduce(function (tabs, container) {
+    tabs.push.apply(tabs, container.children);
+    return tabs;
+  }, []);
+}
+exports.getTabs = getTabs;
+
+function getActiveTab(window) {
+  return window.gBrowser.selectedTab;
+}
+exports.getActiveTab = getActiveTab;
+
+function getOwnerWindow(tab) {
+  return tab.ownerDocument.defaultView;
+}
+exports.getOwnerWindow = getOwnerWindow;
+
+function openTab(window, url) {
+  return window.gBrowser.addTab(url);
+}
+exports.openTab = openTab;
+
+function closeTab(tab) {
+  return getOwnerWindow(tab).gBrowser.removeTab(tab);
+}
+exports.closeTab = closeTab;
+
+function activateTab(tab) {
+  getOwnerWindow(tab).gBrowser.selectedTab = tab;
+}
+exports.activateTab = activateTab;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/test.js b/tools/addon-sdk-1.3/packages/api-utils/lib/test.js
new file mode 100644
index 0000000..0ced3a0
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/test.js
@@ -0,0 +1,126 @@
+/* vim:ts=2:sts=2:sw=2:
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const BaseAssert = require("./test/assert").Assert;
+const { isFunction, isObject } = require("./type");
+
+/**
+ * Function takes test `suite` object in CommonJS format and defines all of the
+ * tests from that suite and nested suites in a jetpack format on a given
+ * `target` object. Optionally third argument `prefix` can be passed to prefix
+ * all the test names.
+ */
+function defineTestSuite(target, suite, prefix) {
+  prefix = prefix || "";
+  // If suite defines `Assert` that's what `assert` object have to be created
+  // from and passed to a test function (This allows custom assertion functions)
+  // See for details: http://wiki.commonjs.org/wiki/Unit_Testing/1.1
+  let Assert = suite.Assert || BaseAssert;
+  // Going through each item in the test suite and wrapping it into a
+  // Jetpack test format.
+  Object.keys(suite).forEach(function(key) {
+     // If name starts with test then it's a test function or suite.
+    if (key.indexOf("test") === 0) {
+      let test = suite[key];
+
+      // For each test function so we create a wrapper test function in a
+      // jetpack format and copy that to a `target` exports.
+      if (isFunction(test)) {
+
+        // Since names of the test may match across suites we use full object
+        // path as a name to avoid overriding same function.
+        target[prefix + key] = function(options) {
+
+          // Creating `assert` functions for this test.
+          let assert = Assert(options);
+
+          // If CommonJS test function expects more than one argument
+          // it means that test is async and second argument is a callback
+          // to notify that test is finished.
+          if (1 < test.length) {
+
+            // Letting test runner know that test is executed async and
+            // creating a callback function that CommonJS tests will call
+            // once it's done.
+            options.waitUntilDone();
+            test(assert, function() {
+              options.done();
+            });
+          }
+
+          // Otherwise CommonJS test is synchronous so we call it only with
+          // one argument.
+          else {
+            test(assert);
+          }
+        }
+      }
+
+      // If it's an object then it's a test suite containing test function
+      // and / or nested test suites. In that case we just extend prefix used
+      // and call this function to copy and wrap tests from nested suite.
+      else if (isObject(test)) {
+        test.Assert = test.Assert || Assert;
+        defineTestSuite(target, test, prefix + key + ".");
+      }
+    }
+  });
+}
+
+/**
+ * This function is a CommonJS test runner function, but since Jetpack test
+ * runner and test format is different from CommonJS this function shims given
+ * `exports` with all its tests into a Jetpack test format so that the built-in
+ * test runner will be able to run CommonJS test without manual changes.
+ */
+exports.run = function run(exports) {
+
+  // We can't leave old properties on exports since those are test in a CommonJS
+  // format that why we move everything to a new `suite` object.
+  let suite = {};
+  Object.keys(exports).forEach(function(key) {
+    suite[key] = exports[key];
+    delete exports[key];
+  });
+
+  // Now we wrap all the CommonJS tests to a Jetpack format and define
+  // those to a given `exports` object since that where jetpack test runner
+  // will look for them.
+  defineTestSuite(exports, suite);
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/test/assert.js b/tools/addon-sdk-1.3/packages/api-utils/lib/test/assert.js
new file mode 100644
index 0000000..0c29d62
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/test/assert.js
@@ -0,0 +1,360 @@
+/* vim:ts=2:sts=2:sw=2:
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { isFunction, isNull, isObject, isString, isRegExp, isArray, isDate,
+        isPrimitive, isUndefined, instanceOf, source } = require("../type");
+
+/**
+ * The `AssertionError` is defined in assert.
+ * @extends Error
+ * @example
+ *  new assert.AssertionError({
+ *    message: message,
+ *    actual: actual,
+ *    expected: expected
+ *  })
+ */
+function AssertionError(options) {
+  let assertionError = Object.create(AssertionError.prototype);
+
+  if (isString(options))
+    options = { message: options };
+  if ("actual" in options)
+    assertionError.actual = options.actual;
+  if ("expected" in options)
+    assertionError.expected = options.expected;
+  if ("operator" in options)
+    assertionError.operator = options.operator;
+
+  assertionError.message = options.message;
+  assertionError.stack = new Error().stack;
+  return assertionError;
+}
+AssertionError.prototype = Object.create(Error.prototype, {
+  constructor: { value: AssertionError },
+  name: { value: "AssertionError", enumerable: true },
+  toString: { value: function toString() {
+    let value;
+    if (this.message) {
+      value = this.name + " : " + this.message;
+    }
+    else {
+      value = [
+        this.name + " : ",
+        source(this.expected),
+        this.operator,
+        source(this.actual)
+      ].join(" ");
+    }
+    return value;
+  }}
+});
+exports.AssertionError = AssertionError;
+
+function Assert(logger) {
+  return Object.create(Assert.prototype, { _log: { value: logger }});
+}
+Assert.prototype = {
+  fail: function fail(e) {
+    this._log.fail(e.message);
+  },
+  pass: function pass(message) {
+    this._log.pass(message);
+  },
+  error: function error(e) {
+    this._log.exception(e);
+  },
+  ok: function ok(value, message) {
+    if (!!!value) {
+      this.fail({
+        actual: value,
+        expected: true,
+        message: message,
+        operator: "=="
+      });
+    }
+    else {
+      this.pass(message);
+    }
+  },
+
+  /**
+   * The equality assertion tests shallow, coercive equality with `==`.
+   * @example
+   *    assert.equal(1, 1, "one is one");
+   */
+  equal: function equal(actual, expected, message) {
+    if (actual == expected) {
+      this.pass(message);
+    }
+    else {
+      this.fail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "=="
+      });
+    }
+  },
+
+  /**
+   * The non-equality assertion tests for whether two objects are not equal
+   * with `!=`.
+   * @example
+   *    assert.notEqual(1, 2, "one is not two");
+   */
+  notEqual: function notEqual(actual, expected, message) {
+    if (actual != expected) {
+      this.pass(message);
+    }
+    else {
+      this.fail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "!=",
+      });
+    }
+  },
+
+  /**
+   * The equivalence assertion tests a deep (with `===`) equality relation.
+   * @example
+   *    assert.deepEqual({ a: "foo" }, { a: "foo" }, "equivalent objects")
+   */
+   deepEqual: function deepEqual(actual, expected, message) {
+    if (isDeepEqual(actual, expected)) {
+      this.pass(message);
+    }
+    else {
+      this.fail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "deepEqual"
+      });
+    }
+  },
+
+  /**
+   * The non-equivalence assertion tests for any deep (with `===`) inequality.
+   * @example
+   *    assert.notDeepEqual({ a: "foo" }, Object.create({ a: "foo" }),
+   *                        "object's inherit from different prototypes");
+   */
+  notDeepEqual: function notDeepEqual(actual, expected, message) {
+    if (!isDeepEqual(actual, expected)) {
+      this.pass(message);
+    }
+    else {
+      this.fail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "notDeepEqual"
+      });
+    }
+  },
+
+  /**
+   * The strict equality assertion tests strict equality, as determined by
+   * `===`.
+   * @example
+   *    assert.strictEqual(null, null, "`null` is `null`")
+   */
+  strictEqual: function strictEqual(actual, expected, message) {
+    if (actual === expected) {
+      this.pass(message);
+    }
+    else {
+      this.fail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "==="
+      });
+    }
+  },
+
+  /**
+   * The strict non-equality assertion tests for strict inequality, as
+   * determined by `!==`.
+   * @example
+   *    assert.notStrictEqual(null, undefined, "`null` is not `undefined`");
+   */
+  notStrictEqual: function notStrictEqual(actual, expected, message) {
+    if (actual !== expected) {
+      this.pass(message);
+    }
+    else {
+      this.fail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "!=="
+      })
+    }
+  },
+
+  /**
+   * The assertion whether or not given `block` throws an exception. If optional
+   * `Error` argument is provided and it's type of function thrown error is
+   * asserted to be an instance of it, if type of `Error` is string then message
+   * of throw exception is asserted to contain it.
+   * @param {Function} block
+   *    Function that is expected to throw.
+   * @param {Error|RegExp} [Error]
+   *    Error constructor that is expected to be thrown or a string that
+   *    must be contained by a message of the thrown exception, or a RegExp
+   *    matching a message of the thrown exception.
+   * @param {String} message
+   *    Description message
+   *
+   * @examples
+   *
+   *    assert.throws(function block() {
+   *      doSomething(4)
+   *    }, "Object is expected", "Incorrect argument is passed");
+   *
+   *    assert.throws(function block() {
+   *      Object.create(5)
+   *    }, TypeError, "TypeError is thrown");
+   */
+  throws: function throws(block, Error, message) {
+    let threw = false;
+    let exception = null;
+
+    // If third argument is not provided and second argument is a string it
+    // means that optional `Error` argument was not passed, so we shift
+    // arguments.
+    if (isString(Error) && isUndefined(message)) {
+      message = Error;
+      Error = undefined;
+    }
+
+    // Executing given `block`.
+    try {
+      block();
+    }
+    catch (e) {
+      threw = true;
+      exception = e;
+    }
+
+    // If exception was thrown and `Error` argument was not passed assert is
+    // passed.
+    if (threw && (isUndefined(Error) ||
+                 // If passed `Error` is RegExp using it's test method to
+                 // assert thrown exception message.
+                 (isRegExp(Error) && Error.test(exception.message)) ||
+                 // If passed `Error` is a constructor function testing if
+                 // thrown exception is an instance of it.
+                 (isFunction(Error) && instanceOf(exception, Error))))
+    {
+      this.pass(message);
+    }
+
+    // Otherwise we report assertion failure.
+    else {
+      let failure = {
+        message: message,
+        operator: "throws"
+      };
+
+      if (exception)
+        failure.actual = exception;
+
+      if (Error)
+        failure.expected = Error;
+
+      this.fail(failure);
+    }
+  }
+};
+exports.Assert = Assert;
+
+function isDeepEqual(actual, expected) {
+
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+  }
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  else if (isDate(actual) && isDate(expected)) {
+    return actual.getTime() === expected.getTime();
+  }
+
+  // XXX specification bug: this should be specified
+  else if (isPrimitive(actual) || isPrimitive(expected)) {
+    return expected === actual;
+  }
+
+  // 7.3. Other pairs that do not both pass typeof value == "object",
+  // equivalence is determined by ==.
+  else if (!isObject(actual) && !isObject(expected)) {
+    return actual == expected;
+  }
+
+  // 7.4. For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical "prototype" property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  else {
+    return actual.prototype === expected.prototype &&
+           isEquivalent(actual, expected);
+  }
+}
+
+function isEquivalent(a, b, stack) {
+  return isArrayEquivalent(Object.keys(a).sort(),
+                           Object.keys(b).sort()) &&
+          Object.keys(a).every(function(key) {
+            return isDeepEqual(a[key], b[key], stack)
+          });
+}
+
+function isArrayEquivalent(a, b, stack) {
+  return isArray(a) && isArray(b) &&
+         a.every(function(value, index) {
+           return isDeepEqual(value, b[index]);
+         });
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/text-streams.js b/tools/addon-sdk-1.3/packages/api-utils/lib/text-streams.js
new file mode 100644
index 0000000..87d375d
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/text-streams.js
@@ -0,0 +1,273 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et filetype=javascript
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Drew Willcoxon <adw@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci,Cu,components} = require("chrome");
+var NetUtil = {};
+Cu.import("resource://gre/modules/NetUtil.jsm", NetUtil);
+NetUtil = NetUtil.NetUtil;
+
+// NetUtil.asyncCopy() uses this buffer length, and since we call it, for best
+// performance we use it, too.
+const BUFFER_BYTE_LEN = 0x8000;
+const PR_UINT32_MAX = 0xffffffff;
+const DEFAULT_CHARSET = "UTF-8";
+
+exports.TextReader = TextReader;
+exports.TextWriter = TextWriter;
+
+/**
+ * An input stream that reads text from a backing stream using a given text
+ * encoding.
+ *
+ * @param inputStream
+ *        The stream is backed by this nsIInputStream.  It must already be
+ *        opened.
+ * @param charset
+ *        Text in inputStream is expected to be in this character encoding.  If
+ *        not given, "UTF-8" is assumed.  See nsICharsetConverterManager.idl for
+ *        documentation on how to determine other valid values for this.
+ */
+function TextReader(inputStream, charset) {
+  const self = this;
+  charset = checkCharset(charset);
+
+  let stream = Cc["@mozilla.org/intl/converter-input-stream;1"].
+               createInstance(Ci.nsIConverterInputStream);
+  stream.init(inputStream, charset, BUFFER_BYTE_LEN,
+              Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
+
+  let manager = new StreamManager(this, stream);
+
+  /**
+   * Reads a string from the stream.  If the stream is closed, an exception is
+   * thrown.
+   *
+   * @param  numChars
+   *         The number of characters to read.  If not given, the remainder of
+   *         the stream is read.
+   * @return The string read.  If the stream is already at EOS, returns the
+   *         empty string.
+   */
+  this.read = function TextReader_read(numChars) {
+    manager.ensureOpened();
+
+    let readAll = false;
+    if (typeof(numChars) === "number")
+      numChars = Math.max(numChars, 0);
+    else
+      readAll = true;
+
+    let str = "";
+    let totalRead = 0;
+    let chunkRead = 1;
+
+    // Read in numChars or until EOS, whichever comes first.  Note that the
+    // units here are characters, not bytes.
+    while (true) {
+      let chunk = {};
+      let toRead = readAll ?
+                   PR_UINT32_MAX :
+                   Math.min(numChars - totalRead, PR_UINT32_MAX);
+      if (toRead <= 0 || chunkRead <= 0)
+        break;
+
+      // The converter stream reads in at most BUFFER_BYTE_LEN bytes in a call
+      // to readString, enough to fill its byte buffer.  chunkRead will be the
+      // number of characters encoded by the bytes in that buffer.
+      chunkRead = stream.readString(toRead, chunk);
+      str += chunk.value;
+      totalRead += chunkRead;
+    }
+
+    return str;
+  };
+}
+
+/**
+ * A buffered output stream that writes text to a backing stream using a given
+ * text encoding.
+ *
+ * @param outputStream
+ *        The stream is backed by this nsIOutputStream.  It must already be
+ *        opened.
+ * @param charset
+ *        Text will be written to outputStream using this character encoding.
+ *        If not given, "UTF-8" is assumed.  See nsICharsetConverterManager.idl
+ *        for documentation on how to determine other valid values for this.
+ */
+function TextWriter(outputStream, charset) {
+  const self = this;
+  charset = checkCharset(charset);
+
+  let stream = outputStream;
+
+  // Buffer outputStream if it's not already.
+  let ioUtils = Cc["@mozilla.org/io-util;1"].getService(Ci.nsIIOUtil);
+  if (!ioUtils.outputStreamIsBuffered(outputStream)) {
+    stream = Cc["@mozilla.org/network/buffered-output-stream;1"].
+             createInstance(Ci.nsIBufferedOutputStream);
+    stream.init(outputStream, BUFFER_BYTE_LEN);
+  }
+
+  // I'd like to use nsIConverterOutputStream.  But NetUtil.asyncCopy(), which
+  // we use below in writeAsync(), naturally expects its sink to be an instance
+  // of nsIOutputStream, which nsIConverterOutputStream's only implementation is
+  // not.  So we use uconv and manually convert all strings before writing to
+  // outputStream.
+  let uconv = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+              createInstance(Ci.nsIScriptableUnicodeConverter);
+  uconv.charset = charset;
+
+  let manager = new StreamManager(this, stream);
+
+  /**
+   * Flushes the backing stream's buffer.
+   */
+  this.flush = function TextWriter_flush() {
+    manager.ensureOpened();
+    stream.flush();
+  };
+
+  /**
+   * Writes a string to the stream.  If the stream is closed, an exception is
+   * thrown.
+   *
+   * @param str
+   *        The string to write.
+   */
+  this.write = function TextWriter_write(str) {
+    manager.ensureOpened();
+    let istream = uconv.convertToInputStream(str);
+    let len = istream.available();
+    while (len > 0) {
+      stream.writeFrom(istream, len);
+      len = istream.available();
+    }
+    istream.close();
+  };
+
+  /**
+   * Writes a string on a background thread.  After the write completes, the
+   * backing stream's buffer is flushed, and both the stream and the backing
+   * stream are closed, also on the background thread.  If the stream is already
+   * closed, an exception is thrown immediately.
+   *
+   * @param str
+   *        The string to write.
+   * @param callback
+   *        An optional function.  If given, it's called as callback(error) when
+   *        the write completes.  error is an Error object or undefined if there
+   *        was no error.  Inside callback, |this| is the stream object.
+   */
+  this.writeAsync = function TextWriter_writeAsync(str, callback) {
+    manager.ensureOpened();
+    let istream = uconv.convertToInputStream(str);
+    NetUtil.asyncCopy(istream, stream, function (result) {
+        let err = components.isSuccessCode(result) ? undefined :
+        new Error("An error occured while writing to the stream: " + result);
+      if (err)
+        console.error(err);
+
+      // asyncCopy() closes its output (and input) stream.
+      manager.opened = false;
+
+      if (typeof(callback) === "function") {
+        try {
+          callback.call(self, err);
+        }
+        catch (exc) {
+          console.exception(exc);
+        }
+      }
+    });
+  };
+}
+
+// This manages the lifetime of stream, a TextReader or TextWriter.  It defines
+// closed and close() on stream and registers an unload listener that closes
+// rawStream if it's still opened.  It also provides ensureOpened(), which
+// throws an exception if the stream is closed.
+function StreamManager(stream, rawStream) {
+  const self = this;
+  this.rawStream = rawStream;
+  this.opened = true;
+
+  /**
+   * True iff the stream is closed.
+   */
+  stream.__defineGetter__("closed", function stream_closed() {
+    return !self.opened;
+  });
+
+  /**
+   * Closes both the stream and its backing stream.  If the stream is already
+   * closed, an exception is thrown.  For TextWriters, this first flushes the
+   * backing stream's buffer.
+   */
+  stream.close = function stream_close() {
+    self.ensureOpened();
+    self.unload();
+  };
+
+  require("./unload").ensure(this);
+}
+
+StreamManager.prototype = {
+  ensureOpened: function StreamManager_ensureOpened() {
+    if (!this.opened)
+      throw new Error("The stream is closed and cannot be used.");
+  },
+  unload: function StreamManager_unload() {
+    // TextWriter.writeAsync() causes rawStream to close and therefore sets
+    // opened to false, so check that we're still opened.
+    if (this.opened) {
+      // Calling close() on both an nsIUnicharInputStream and
+      // nsIBufferedOutputStream closes their backing streams.  It also forces
+      // nsIOutputStreams to flush first.
+      this.rawStream.close();
+      this.opened = false;
+    }
+  }
+};
+
+function checkCharset(charset) {
+  return typeof(charset) === "string" ? charset : DEFAULT_CHARSET;
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/timer-e10s-adapter.js b/tools/addon-sdk-1.3/packages/api-utils/lib/timer-e10s-adapter.js
new file mode 100644
index 0000000..c0dc313
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/timer-e10s-adapter.js
@@ -0,0 +1,75 @@
+// This implementation is neither secure nor complete,
+// because timer functionality should be implemented
+// natively in-process by bug 568695.
+
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+if (this.chrome) {
+  var callbacks = {};
+  exports.setTimeout = function setTimeout(cb, ms) {
+    var id = chrome.call("setTimeout", ms);
+    callbacks[id] = cb;
+    return id;
+  };
+
+  exports.clearTimeout = function clearTimeout(id) {
+    delete callbacks[id];
+    chrome.send("clearTimeout", id);
+  };
+  
+  chrome.on("onTimeout", function(name, id) {
+    var cb = callbacks[id];
+    delete callbacks[id];
+    if (cb)
+      cb(); // yay race conditions
+  });
+} else {
+  exports.register = function(addon) {
+    var timer = require("./timer");
+    addon.registerCall("setTimeout", function(name, ms) {
+      var id = timer.setTimeout(function() {
+        addon.send("onTimeout", id);
+      }, ms);
+      return id;
+    });
+    addon.on("clearTimeout", function(name, id) {
+      timer.clearTimeout(id);
+    });
+  };
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/timer.js b/tools/addon-sdk-1.3/packages/api-utils/lib/timer.js
new file mode 100644
index 0000000..052f506
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/timer.js
@@ -0,0 +1,141 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *   Drew Willcoxon <adw@mozilla.com>
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *   Erik Vold <erikvvold@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci} = require("chrome");
+var xpcom = require("./xpcom");
+
+var timerClass = Cc["@mozilla.org/timer;1"];
+var nextID = 1;
+var timers = {};
+
+function TimerCallback(timerID, callback, params) {
+  this._callback = callback;
+  this._params = params;
+};
+TimerCallback.prototype = {
+  QueryInterface : xpcom.utils.generateQI([Ci.nsITimerCallback])
+};
+
+function TimeoutCallback(timerID, callback, params) {
+  memory.track(this);
+  TimerCallback.apply(this, arguments)
+  this._timerID = timerID;
+};
+TimeoutCallback.prototype = new TimerCallback();
+TimeoutCallback.prototype.notify = function notifyOnTimeout(timer) {
+  try {
+    delete timers[this._timerID];
+    this._callback.apply(null, this._params);
+  } catch (e) {
+    console.exception(e);
+  }
+};
+
+function IntervalCallback(timerID, callback, params) {
+  memory.track(this);
+  TimerCallback.apply(this, arguments)
+};
+IntervalCallback.prototype = new TimerCallback();
+IntervalCallback.prototype.notify = function notifyOnInterval() {
+  try {
+    this._callback.apply(null, this._params);
+  } catch (e) {
+    console.exception(e);
+  }
+};
+
+
+var setTimeout = exports.setTimeout = function setTimeout(callback, delay) {
+  return makeTimer(
+    Ci.nsITimer.TYPE_ONE_SHOT,
+    callback,
+    TimeoutCallback,
+    delay,
+    Array.slice(arguments, 2));
+};
+
+var clearTimeout = exports.clearTimeout = function clearTimeout(timerID) {
+  cancelTimer(timerID);
+};
+
+var setInterval = exports.setInterval = function setInterval(callback, delay) {
+  return makeTimer(
+    Ci.nsITimer.TYPE_REPEATING_SLACK,
+    callback,
+    IntervalCallback,
+    delay,
+    Array.slice(arguments, 2));
+};
+
+var clearInterval = exports.clearInterval = function clearInterval(timerID) {
+  cancelTimer(timerID);
+};
+
+function makeTimer(type, callback, callbackType, delay, params) {
+  var timer = timerClass.createInstance(Ci.nsITimer);
+
+  memory.track(timer, "nsITimer");
+
+  var timerID = nextID++;
+  timers[timerID] = timer;
+
+  timer.initWithCallback(
+    new callbackType(timerID, callback, params),
+    delay || 0,
+    type
+  );
+  return timerID;
+}
+
+function cancelTimer(timerID) {
+  var timer = timers[timerID];
+  if (timer) {
+    timer.cancel();
+    delete timers[timerID];
+  }
+}
+
+require("./unload").when(
+  function cancelAllPendingTimers() {
+    var timerIDs = [timerID for (timerID in timers)];
+    timerIDs.forEach(function(timerID) { cancelTimer(timerID); });
+  });
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/traceback.js b/tools/addon-sdk-1.3/packages/api-utils/lib/traceback.js
new file mode 100644
index 0000000..fdedd99
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/traceback.js
@@ -0,0 +1,155 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci,components} = require("chrome");
+
+// Undo the auto-parentification of URLs done in bug 418356.
+function deParentifyURL(url) {
+  return url ? url.split(" -> ").slice(-1)[0] : url;
+}
+
+// TODO: We might want to move this function to url or some similar
+// module.
+function getLocalFile(path) {
+  var ios = Cc['@mozilla.org/network/io-service;1']
+            .getService(Ci.nsIIOService);
+  var channel = ios.newChannel(path, null, null);
+  var iStream = channel.open();
+  var siStream = Cc['@mozilla.org/scriptableinputstream;1']
+                 .createInstance(Ci.nsIScriptableInputStream);
+  siStream.init(iStream);
+  var data = new String();
+  data += siStream.read(-1);
+  siStream.close();
+  iStream.close();
+  return data;
+}
+
+function safeGetFileLine(path, line) {
+  try {
+    var scheme = require("./url").URL(path).scheme;
+    // TODO: There should be an easier, more accurate way to figure out
+    // what's the case here.
+    if (!(scheme == "http" || scheme == "https"))
+      return getLocalFile(path).split("\n")[line - 1];
+  } catch (e) {}
+  return null;
+}
+
+function errorStackToJSON(stack) {
+  var lines = stack.split("\n");
+
+  var frames = [];
+  lines.forEach(
+    function(line) {
+      if (!line)
+        return;
+      var atIndex = line.indexOf("@");
+      var colonIndex = line.lastIndexOf(":");
+      var filename = deParentifyURL(line.slice(atIndex + 1, colonIndex));
+      var lineNo = parseInt(line.slice(colonIndex + 1));
+      var funcSig = line.slice(0, atIndex);
+      var funcName = funcSig.slice(0, funcSig.indexOf("("));
+      frames.unshift({filename: filename,
+                      funcName: funcName,
+                      lineNo: lineNo});
+    });
+
+  return frames;
+};
+
+function nsIStackFramesToJSON(frame) {
+  var stack = [];
+
+  while (frame) {
+    if (frame.filename) {
+      var filename = deParentifyURL(frame.filename);
+      stack.splice(0, 0, {filename: filename,
+                          lineNo: frame.lineNumber,
+                          funcName: frame.name});
+    }
+    frame = frame.caller;
+  }
+
+  return stack;
+};
+
+var fromException = exports.fromException = function fromException(e) {
+  if (e instanceof Ci.nsIException)
+    return nsIStackFramesToJSON(e.location);
+  if (e.stack && e.stack.length)
+    return errorStackToJSON(e.stack);
+  if (e.fileName && typeof(e.lineNumber == "number"))
+    return [{filename: deParentifyURL(e.fileName),
+             lineNo: e.lineNumber,
+             funcName: null}];
+  return [];
+};
+
+var get = exports.get = function get() {
+  return nsIStackFramesToJSON(components.stack.caller);
+};
+
+var format = exports.format = function format(tbOrException) {
+  if (tbOrException === undefined) {
+    tbOrException = get();
+    tbOrException.splice(-1, 1);
+  }
+
+  var tb;
+  if (typeof(tbOrException) == "object" &&
+      tbOrException.constructor.name == "Array")
+    tb = tbOrException;
+  else
+    tb = fromException(tbOrException);
+
+  var lines = ["Traceback (most recent call last):"];
+
+  tb.forEach(
+    function(frame) {
+      if (!(frame.filename || frame.lineNo || frame.funcName))
+	return;
+      lines.push('  File "' + frame.filename + '", line ' +
+                 frame.lineNo + ', in ' + frame.funcName);
+      var sourceLine = safeGetFileLine(frame.filename, frame.lineNo);
+      if (sourceLine)
+        lines.push('    ' + sourceLine.trim());
+    });
+
+  return lines.join("\n");
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/traits.js b/tools/addon-sdk-1.3/packages/api-utils/lib/traits.js
new file mode 100644
index 0000000..59193aa
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/traits.js
@@ -0,0 +1,215 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {
+  compose: _compose,
+  override: _override,
+  resolve: _resolve,
+  trait: _trait,
+  //create: _create,
+  required,
+} = require('./traits/core');
+
+const defineProperties = Object.defineProperties,
+      freeze = Object.freeze,
+      create = Object.create;
+
+/**
+ * Work around bug 608959 by defining the _create function here instead of
+ * importing it from traits/core.  For docs on this function, see the create
+ * function in that module.
+ *
+ * FIXME: remove this workaround in favor of importing the function once that
+ * bug has been fixed.
+ */
+function _create(proto, trait) {
+  let properties = {},
+      keys = Object.getOwnPropertyNames(trait);
+  for each(let key in keys) {
+    let descriptor = trait[key];
+    if (descriptor.required &&
+        !Object.prototype.hasOwnProperty.call(proto, key))
+      throw new Error('Missing required property: ' + key);
+    else if (descriptor.conflict)
+      throw new Error('Remaining conflicting property: ' + key);
+    else
+      properties[key] = descriptor;
+  }
+  return Object.create(proto, properties);
+}
+
+/**
+ * Placeholder for `Trait.prototype`
+ */
+let TraitProto = Object.prototype;
+
+function Get(key) this[key]
+function Set(key, value) this[key] = value
+
+/**
+ * Creates anonymous trait descriptor from the passed argument, unless argument
+ * is a trait constructor. In later case trait's already existing properties
+ * descriptor is returned.
+ * This is module's internal function and is used as a gateway to a trait's
+ * internal properties descriptor.
+ * @param {Function} $
+ *    Composed trait's constructor.
+ * @returns {Object}
+ *    Private trait property of the composition.
+ */
+function TraitDescriptor(object)
+  (
+    'function' == typeof object &&
+    (object.prototype == TraitProto || object.prototype instanceof Trait)
+  ) ? object._trait(TraitDescriptor) : _trait(object)
+
+function Public(instance, trait) {
+  let result = {},
+      keys = Object.getOwnPropertyNames(trait);
+  for each (let key in keys) {
+    if ('_' === key.charAt(0) && '__iterator__' !== key )
+      continue;
+    let property = trait[key],
+        descriptor = {
+          configurable: property.configurable,
+          enumerable: property.enumerable
+        };
+    if (property.get)
+      descriptor.get = property.get.bind(instance);
+    if (property.set)
+      descriptor.set = property.set.bind(instance);
+    if ('value' in property) {
+      let value = property.value;
+      if ('function' === typeof value) {
+        descriptor.value = property.value.bind(instance);
+        descriptor.writable = property.writable;
+      } else {
+        descriptor.get = Get.bind(instance, key);
+        descriptor.set = Set.bind(instance, key);
+      }
+    }
+    result[key] = descriptor;
+  }
+  return result;
+}
+
+/**
+ * This is private function that composes new trait with privates.
+ */
+function Composition(trait) {
+  function Trait() {
+    let self = _create({}, trait);
+    self._public = create(Trait.prototype, Public(self, trait));
+    delete self._public.constructor;
+    if (Object === self.constructor)
+      self.constructor = Trait;
+    else
+      return self.constructor.apply(self, arguments) || self._public;
+    return self._public;
+  }
+  defineProperties(Trait, {
+    prototype: { value: freeze(create(TraitProto, {
+      constructor: { value: constructor, writable: true }
+    }))}, // writable is `true` to avoid getters in custom ES5
+    displayName: { value: (trait.constructor || constructor).name },
+    compose: { value: compose, enumerable: true },
+    override: { value: override, enumerable: true },
+    resolve: { value: resolve, enumerable: true },
+    required: { value: required, enumerable: true },
+    _trait: { value: function _trait(caller)
+        caller ===  TraitDescriptor ? trait : undefined
+    }
+  });
+  return freeze(Trait);
+}
+
+/**
+ * Composes new trait out of itself and traits / property maps passed as an
+ * arguments. If two or more traits / property maps have properties with the
+ * same name, the new trait will contain a "conflict" property for that name.
+ * This is a commutative and associative operation, and the order of its
+ * arguments is not significant.
+ * @params {Object|Function}
+ *    List of Traits or property maps to create traits from.
+ * @returns {Function}
+ *    New trait containing the combined properties of all the traits.
+ */
+function compose() {
+  let traits = Array.slice(arguments, 0);
+  traits.push(this);
+  return Composition(_compose.apply(null, traits.map(TraitDescriptor)));
+}
+
+/**
+ * Composes a new trait with all of the combined properties of `this` and the
+ * argument traits. In contrast to `compose`, `override` immediately resolves
+ * all conflicts resulting from this composition by overriding the properties of
+ * later traits. Trait priority is from left to right. I.e. the properties of
+ * the leftmost trait are never overridden.
+ * @params {Object} trait
+ * @returns {Object}
+ */
+function override() {
+  let traits = Array.slice(arguments, 0);
+  traits.push(this);
+  return Composition(_override.apply(null, traits.map(TraitDescriptor)));
+}
+
+/**
+ * Composes new resolved trait, with all the same properties as this
+ * trait, except that all properties whose name is an own property of
+ * `resolutions` will be renamed to `resolutions[name]`. If it is
+ * `resolutions[name]` is `null` value is changed into a required property
+ * descriptor.
+ */
+function resolve(resolutions)
+  Composition(_resolve(resolutions, TraitDescriptor(this)))
+
+/**
+ * Base Trait, that all the traits are composed of.
+ */
+const Trait = Composition({
+  /**
+   * Internal property holding public API of this instance.
+   */
+  _public: { value: null, configurable: true, writable: true },
+  toString: { value: function() '[object ' + this.constructor.name + ']' }
+});
+TraitProto = Trait.prototype;
+exports.Trait = Trait;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/traits/core.js b/tools/addon-sdk-1.3/packages/api-utils/lib/traits/core.js
new file mode 100644
index 0000000..c17dee7
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/traits/core.js
@@ -0,0 +1,339 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+// Design inspired by: http://www.traitsjs.org/
+
+// shortcuts
+const getOwnPropertyNames = Object.getOwnPropertyNames,
+      getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,
+      hasOwn = Object.prototype.hasOwnProperty,
+      _create = Object.create;
+/**
+ * Compares two trait custom property descriptors if they are the same. If
+ * both are `conflict` or all the properties of descriptor are equal returned
+ * value will be `true`, otherwise it will be `false`.
+ * @param {Object} desc1
+ * @param {Object} desc2
+ */
+function areSame(desc1, desc2) {
+  return (desc1.conflict && desc2.conflict) || (
+    desc1.get === desc2.get &&
+    desc1.set === desc2.set &&
+    desc1.value === desc2.value &&
+    desc1.enumerable === desc2.enumerable &&
+    desc1.required === desc2.required &&
+    desc1.conflict === desc2.conflict
+  );
+}
+
+/**
+ * Converts array to an object whose own property names represent
+ * values of array.
+ * @param {String[]} names
+ * @returns {Object}
+ * @example
+ *  Map(['foo', ...]) => { foo: true, ...}
+ */
+function Map(names) {
+  let map = {};
+  for each (let name in names)
+    map[name] = true;
+  return map;
+}
+
+
+const ERR_CONFLICT = 'Remaining conflicting property: ',
+      ERR_REQUIRED = 'Missing required property: ';
+/**
+ * Constant singleton, representing placeholder for required properties.
+ * @type {Object}
+ */
+const required = { toString: function()'<Trait.required>' };
+exports.required = required;
+
+/**
+ * Generates custom **required** property descriptor. Descriptor contains
+ * non-standard property `required` that is equal to `true`.
+ * @param {String} name
+ *    property name to generate descriptor for.
+ * @returns {Object}
+ *    custom property descriptor
+ */
+function Required(name) {
+  function required() { throw new Error(ERR_REQUIRED + name) }
+  return {
+    get: required,
+    set: required,
+    required: true
+  };
+}
+
+/**
+ * Generates custom **conflicting** property descriptor. Descriptor contains
+ * non-standard property `conflict` that is equal to `true`.
+ * @param {String} name
+ *    property name to generate descriptor for.
+ * @returns {Object}
+ *    custom property descriptor
+ */
+function Conflict(name) {
+  function conflict() { throw new Error(ERR_CONFLICT + name) }
+  return {
+    get: conflict,
+    set: conflict,
+    conflict: true
+  };
+}
+
+/**
+ * Function generates custom properties descriptor of the `object`s own
+ * properties. All the inherited properties are going to be ignored.
+ * Properties with values matching `required` singleton will be marked as
+ * 'required' properties.
+ * @param {Object} object
+ *    Set of properties to generate trait from.
+ * @returns {Object}
+ *    Properties descriptor of all of the `object`'s own properties.
+ */
+function trait(properties) {
+  let result = {},
+      keys = getOwnPropertyNames(properties);
+ for each (let key in keys) {
+   let descriptor = getOwnPropertyDescriptor(properties, key);
+   result[key] = (required === descriptor.value) ? Required(key) : descriptor;
+ }
+ return result;
+}
+exports.Trait = exports.trait = trait;
+
+/**
+ * Composes new trait. If two or more traits have own properties with the
+ * same name, the new trait will contain a 'conflict' property for that name.
+ * 'compose' is a commutative and associative operation, and the order of its
+ * arguments is not significant.
+ *
+ * @params {Object} trait
+ *    Takes traits as an arguments
+ * @returns {Object}
+ *    New trait containing the combined own properties of all the traits.
+ * @example
+ *    var newTrait = compose(trait_1, trait_2, ..., trait_N);
+ */
+function compose(trait1, trait2) {
+  let traits = Array.slice(arguments, 0),
+      result = {};
+  for each (let trait in traits) {
+    let keys = getOwnPropertyNames(trait);
+    for each (let key in keys) {
+      let descriptor = trait[key];
+      // if property already exists and it's not a requirement
+      if (hasOwn.call(result, key) && !result[key].required) {
+        if (descriptor.required)
+          continue;
+        if (!areSame(descriptor, result[key]))
+          result[key] = Conflict(key);
+      } else {
+        result[key] = descriptor;
+      }
+    }
+  }
+  return result;
+}
+exports.compose = compose;
+
+/**
+ * Composes new trait with the same own properties as the original trait,
+ * except that all property names appearing in the first argument are replaced
+ * by 'required' property descriptors.
+ * @param {String[]} keys
+ *    Array of strings property names.
+ * @param {Object} trait
+ *    A trait some properties of which should be excluded.
+ * @returns {Object}
+ * @example
+ *    var newTrait = exclude(['name', ...], trait)
+ */
+function exclude(keys, trait) {
+  let exclusions = Map(keys),
+      result = {};
+
+  keys = getOwnPropertyNames(trait);
+
+  for each (let key in keys) {
+    if (!hasOwn.call(exclusions, key) || trait[key].required)
+      result[key] = trait[key];
+    else
+      result[key] = Required(key);
+  }
+  return result;
+}
+
+/**
+ * Composes a new trait with all of the combined properties of the argument
+ * traits. In contrast to `compose`, `override` immediately resolves all
+ * conflicts resulting from this composition by overriding the properties of
+ * later traits. Trait priority is from left to right. I.e. the properties of
+ * the leftmost trait are never overridden.
+ * @params {Object} trait
+ * @returns {Object}
+ * @examples
+ *    // override is associative:
+ *    override(t1,t2,t3)
+ *    // is equivalent to
+ *    override(t1, override(t2, t3))
+ *    // or
+ *    to override(override(t1, t2), t3)
+ *
+ *    // override is not commutative:
+ *    override(t1,t2)
+ *    // is not equivalent to
+ *    override(t2,t1)
+ */
+function override() {
+  let traits = Array.slice(arguments, 0),
+      result = {};
+  for each (let trait in traits) {
+    let keys = getOwnPropertyNames(trait);
+    for each(let key in keys) {
+      let descriptor = trait[key];
+      if (!hasOwn.call(result, key) || result[key].required)
+        result[key] = descriptor;
+    }
+  }
+  return result;
+}
+exports.override = override;
+
+/**
+ * Composes a new trait with the same properties as the original trait, except
+ * that all properties whose name is an own property of map will be renamed to
+ * map[name], and a 'required' property for name will be added instead.
+ * @param {Object} map
+ *    An object whose own properties serve as a mapping from old names to new
+ *    names.
+ * @param {Object} trait
+ *    A trait object
+ * @returns {Object}
+ * @example
+ *    var newTrait = rename(map, trait);
+ */
+function rename(map, trait) {
+  let result = {},
+      keys = getOwnPropertyNames(trait);
+  for each(let key in keys) {
+    // must be renamed & it's not requirement
+    if (hasOwn.call(map, key) && !trait[key].required) {
+      let alias = map[key];
+      if (hasOwn.call(result, alias) && !result[alias].required)
+        result[alias] = Conflict(alias);
+      else
+        result[alias] = trait[key];
+      if (!hasOwn.call(result, key))
+        result[key] = Required(key);
+    } else { // must not be renamed or its a requirement
+      // property is not in result trait yet
+      if (!hasOwn.call(result, key))
+        result[key] = trait[key];
+      // property is already in resulted trait & it's not requirement
+      else if (!trait[key].required)
+        result[key] = Conflict(key);
+    }
+  }
+  return result;
+}
+
+/**
+* Composes new resolved trait, with all the same properties as the original
+* trait, except that all properties whose name is an own property of
+* resolutions will be renamed to `resolutions[name]`. If it is
+* `resolutions[name]` is `null` value is changed into a required property
+* descriptor.
+* function can be implemented as `rename(map,exclude(exclusions, trait))`
+* where map is the subset of mappings from oldName to newName and exclusions
+* is an array of all the keys that map to `null`.
+* Note: it's important to **first** `exclude`, **then** `rename`, since
+* `exclude` and rename are not associative.
+* @param {Object} resolutions
+*   An object whose own properties serve as a mapping from old names to new
+*   names, or to `null` if the property should be excluded.
+* @param {Object} trait
+*   A trait object
+* @returns {Object}
+*   Resolved trait with the same own properties as the original trait.
+*/
+function resolve(resolutions, trait) {
+  let renames = {},
+      exclusions = [],
+      keys = getOwnPropertyNames(resolutions);
+  for each (let key in keys) {  // pre-process renamed and excluded properties
+    if (resolutions[key])       // old name -> new name
+      renames[key] = resolutions[key];
+    else                        // name -> undefined
+      exclusions.push(key);
+  }
+  return rename(renames, exclude(exclusions, trait));
+}
+exports.resolve = resolve;
+
+/**
+ * `create` is like `Object.create`, except that it ensures that:
+ *    - an exception is thrown if 'trait' still contains required properties
+ *    - an exception is thrown if 'trait' still contains conflicting
+ *      properties
+ * @param {Object}
+ *    prototype of the completed object
+ * @param {Object} trait
+ *    trait object to be turned into a complete object
+ * @returns {Object}
+ *    An object with all of the properties described by the trait.
+ */
+function create(proto, trait) {
+  let properties = {},
+      keys = getOwnPropertyNames(trait);
+  for each(let key in keys) {
+    let descriptor = trait[key];
+    if (descriptor.required && !hasOwn.call(proto, key))
+      throw new Error(ERR_REQUIRED + key);
+    else if (descriptor.conflict)
+      throw new Error(ERR_CONFLICT + key);
+    else
+      properties[key] = descriptor;
+  }
+  return _create(proto, properties);
+}
+exports.create = create;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/type.js b/tools/addon-sdk-1.3/packages/api-utils/lib/type.js
new file mode 100644
index 0000000..012d2d1
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/type.js
@@ -0,0 +1,372 @@
+/* vim:ts=2:sts=2:sw=2:
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+/**
+ * Returns `true` if `value` is `undefined`.
+ * @examples
+ *    var foo; isUndefined(foo); // true
+ *    isUndefined(0); // false
+ */
+function isUndefined(value) {
+  return value === undefined;
+}
+exports.isUndefined = isUndefined;
+
+/**
+ * Returns `true` if value is `null`.
+ * @examples
+ *    isNull(null); // true
+ *    isNull(undefined); // false
+ */
+function isNull(value) {
+  return value === null;
+}
+exports.isNull = isNull;
+
+/**
+ * Returns `true` if value is a string.
+ * @examples
+ *    isString("moe"); // true
+ */
+function isString(value) {
+  return typeof value === "string";
+}
+exports.isString = isString;
+
+/**
+ * Returns `true` if `value` is a number.
+ * @examples
+ *    isNumber(8.4 * 5); // true
+ */
+function isNumber(value) {
+  return typeof value === "number";
+}
+exports.isNumber = isNumber;
+
+/**
+ * Returns `true` if `value` is a `RegExp`.
+ * @examples
+ *    isRegExp(/moe/); // true
+ */
+function isRegExp(value) {
+  return isObject(value) && instanceOf(value, RegExp);
+}
+exports.isRegExp = isRegExp;
+
+/**
+ * Returns true if `value` is a `Date`.
+ * @examples
+ *    isDate(new Date()); // true
+ */
+function isDate(value) {
+  return isObject(value) && instanceOf(value, Date);
+}
+exports.isDate = isDate;
+
+/**
+ * Returns true if object is a Function.
+ * @examples
+ *    isFunction(function foo(){}) // true
+ */
+function isFunction(value) {
+    return typeof value === "function";
+}
+exports.isFunction = isFunction;
+
+/**
+ * Returns `true` if `value` is an object (please note that `null` is considered
+ * to be an atom and not an object).
+ * @examples
+ *    isObject({}) // true
+ *    isObject(null) // false
+ */
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+exports.isObject = isObject;
+
+/**
+ * Returns true if `value` is an Array.
+ * @examples
+ *    isArray([1, 2, 3])  // true
+ *    isArray({ 0: 'foo', length: 1 }) // false
+ */
+var isArray = Array.isArray || function isArray(value) {
+  Object.prototype.toString.call(value) === "[object Array]";
+}
+exports.isArray = isArray;
+
+/**
+ * Returns `true` if `value` is an Arguments object.
+ * @examples
+ *    (function(){ return isArguments(arguments); })(1, 2, 3); // true
+ *    isArguments([1,2,3]); // false
+ */
+function isArguments(value) {
+  Object.prototype.toString.call(value) === "[object Arguments]";
+}
+exports.isArguments = isArguments;
+
+/**
+ * Returns true if it is a primitive `value`. (null, undefined, number,
+ * boolean, string)
+ * @examples
+ *    isPrimitive(3) // true
+ *    isPrimitive('foo') // true
+ *    isPrimitive({ bar: 3 }) // false
+ */
+function isPrimitive(value) {
+  return !isFunction(value) && !isObject(value);
+}
+exports.isPrimitive = isPrimitive;
+
+/**
+ * Returns `true` if given `object` is flat (it is direct decedent of
+ * `Object.prototype` or `null`).
+ * @examples
+ *    isFlat({}) // true
+ *    isFlat(new Type()) // false
+ */
+function isFlat(object) {
+  return isObject(object) && (isNull(Object.getPrototypeOf(object)) ||
+                              isNull(Object.getPrototypeOf(
+                                     Object.getPrototypeOf(object))));
+}
+exports.isFlat = isFlat;
+
+/**
+ * Returns `true` if object contains no values.
+ */
+function isEmpty(object) {
+  if (isObject(object)) {
+    for (var key in object)
+      return false;
+    return true;
+  }
+  return false;
+}
+exports.isEmpty = isEmpty;
+
+/**
+ * Returns `true` if `value` is an array / flat object containing only atomic
+ * values and other flat objects.
+ */
+function isJSON(value, visited) {
+    // Adding value to array of visited values.
+    (visited || (visited = [])).push(value);
+            // If `value` is an atom return `true` cause it's valid JSON.
+    return  isPrimitive(value) ||
+            // If `value` is an array of JSON values that has not been visited
+            // yet.
+            (isArray(value) &&  value.every(function(element) {
+                                  return isJSON(element, visited);
+                                })) ||
+            // If `value` is a plain object containing properties with a JSON
+            // values it's a valid JSON.
+            (isFlat(value) && Object.keys(value).every(function(key) {
+                var $ = Object.getOwnPropertyDescriptor(value, key);
+                // Check every proprety of a plain object to verify that
+                // it's neither getter nor setter, but a JSON value, that
+                // has not been visited yet.
+                return  ((!isObject($.value) || !~visited.indexOf($.value)) &&
+                        !('get' in $) && !('set' in $) &&
+                        isJSON($.value, visited));
+            }));
+}
+exports.isJSON = function (value) {
+  return isJSON(value);
+};
+
+/**
+ * Returns if `value` is an instance of a given `Type`. This is exactly same as
+ * `value instanceof Type` with a difference that `Type` can be from a scope
+ * that has a different top level object. (Like in case where `Type` is a
+ * function from different iframe / jetpack module / sandbox).
+ */
+function instanceOf(value, Type) {
+  var isConstructorNameSame;
+  var isConstructorSourceSame;
+
+  // If `instanceof` returned `true` we know result right away.
+  var isInstanceOf = value instanceof Type;
+
+  // If `instanceof` returned `false` we do ducktype check since `Type` may be
+  // from a different sandbox. If a constructor of the `value` or a constructor
+  // of the value's prototype has same name and source we assume that it's an
+  // instance of the Type.
+  if (!isInstanceOf && value) {
+    isConstructorNameSame = value.constructor.name === Type.name;
+    isConstructorSourceSame = String(value.constructor) == String(Type);
+    isInstanceOf = (isConstructorNameSame && isConstructorSourceSame) ||
+                    instanceOf(Object.getPrototypeOf(value), Type);
+  }
+  return isInstanceOf;
+}
+exports.instanceOf = instanceOf;
+
+/**
+ * Function returns textual representation of a value passed to it. Function
+ * takes additional `indent` argument that is used for indentation. Also
+ * optional `limit` argument may be passed to limit amount of detail returned.
+ * @param {Object} value
+ * @param {String} [indent="    "]
+ * @param {Number} [limit]
+ */
+function source(value, indent, limit, offset, visited) {
+  var result;
+  var names;
+  var nestingIndex;
+  var isCompact = !isUndefined(limit);
+
+  indent = indent || "    ";
+  offset = (offset || "");
+  result = "";
+  visited = visited || [];
+
+  if (isUndefined(value)) {
+    result += "undefined";
+  }
+  else if (isNull(value)) {
+    result += "null";
+  }
+  else if (isString(value)) {
+    result += '"' + value + '"';
+  }
+  else if (isFunction(value)) {
+    value = String(value).split("\n");
+    if (isCompact && value.length > 2) {
+      value = value.splice(0, 2);
+      value.push("...}");
+    }
+    result += value.join("\n" + offset);
+  }
+  else if (isArray(value)) {
+    if ((nestingIndex = (visited.indexOf(value) + 1))) {
+      result = "#" + nestingIndex + "#";
+    }
+    else {
+      visited.push(value);
+
+      if (isCompact)
+        value = value.slice(0, limit);
+
+      result += "[\n";
+      result += value.map(function(value) {
+        return offset + indent + source(value, indent, limit, offset + indent,
+                                        visited);
+      }).join(",\n");
+      result += isCompact && value.length > limit ?
+                ",\n" + offset + "...]" : "\n" + offset + "]";
+    }
+  }
+  else if (isObject(value)) {
+    if ((nestingIndex = (visited.indexOf(value) + 1))) {
+      result = "#" + nestingIndex + "#"
+    }
+    else {
+      visited.push(value)
+
+      names = Object.keys(value);
+
+      result += "{ // " + value + "\n";
+      result += (isCompact ? names.slice(0, limit) : names).map(function(name) {
+        var _limit = isCompact ? limit - 1 : limit;
+        var descriptor = Object.getOwnPropertyDescriptor(value, name);
+        var result = offset + indent + "// ";
+        var accessor;
+        if (0 <= name.indexOf(" "))
+          name = '"' + name + '"';
+
+        if (descriptor.writable)
+          result += "writable ";
+        if (descriptor.configurable)
+          result += "configurable ";
+        if (descriptor.enumerable)
+          result += "enumerable ";
+
+        result += "\n";
+        if ("value" in descriptor) {
+          result += offset + indent + name + ": ";
+          result += source(descriptor.value, indent, _limit, indent + offset,
+                           visited);
+        }
+        else {
+
+          if (descriptor.get) {
+            result += offset + indent + "get " + name + " ";
+            accessor = source(descriptor.get, indent, _limit, indent + offset,
+                              visited);
+            result += accessor.substr(accessor.indexOf("{"));
+          }
+
+          if (descriptor.set) {
+            result += offset + indent + "set " + name + " ";
+            accessor = source(descriptor.set, indent, _limit, indent + offset,
+                              visited);
+            result += accessor.substr(accessor.indexOf("{"));
+          }
+        }
+        return result;
+      }).join(",\n");
+
+      if (isCompact) {
+        if (names.length > limit && limit > 0) {
+          result += ",\n" + offset  + indent + "//...";
+        }
+      }
+      else {
+        if (names.length)
+          result += ",";
+
+        result += "\n" + offset + indent + '"__proto__": ';
+        result += source(Object.getPrototypeOf(value), indent, 0,
+                         offset + indent);
+      }
+
+      result += "\n" + offset + "}";
+    }
+  }
+  else {
+    result += String(value);
+  }
+  return result;
+}
+exports.source = function (value, indentation, limit) {
+  return source(value, indentation, limit);
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/unit-test-finder.js b/tools/addon-sdk-1.3/packages/api-utils/lib/unit-test-finder.js
new file mode 100644
index 0000000..6a13c39
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/unit-test-finder.js
@@ -0,0 +1,117 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+// We don't actually use chrome directly, but we do access the 
+// filesystem and scan it to dynamically import modules, so
+// we put this here to tell the module loader to give us
+// permission to require() whatever we want.
+require("chrome");
+
+var file = require("./file");
+const NOT_TESTS = ['setup', 'teardown'];
+
+var TestFinder = exports.TestFinder = function TestFinder(options) {
+  memory.track(this);
+  this.dirs = options.dirs || [];
+  this.filter = options.filter;
+  this.testInProcess = options.testInProcess === false ? false : true;
+  this.testOutOfProcess = options.testOutOfProcess === true ? true : false;
+};
+
+TestFinder.prototype = {
+  _makeTest: function _makeTest(suite, name, test) {
+    function runTest(runner) {
+      console.info("executing '" + suite + "." + name + "'");
+      test(runner);
+    }
+    return runTest;
+  },
+
+  findTests: function findTests(cb) {
+    var self = this;
+    var tests = [];
+    var filter;
+    // A filter string is {fileNameRegex}[:{testNameRegex}] - ie, a colon
+    // optionally separates a regex for the test fileName from a regex for the
+    // testName.
+    if (this.filter) {
+      var colonPos = this.filter.indexOf(':');
+      var filterFileRegex, filterNameRegex;
+      if (colonPos === -1) {
+        filterFileRegex = new RegExp(self.filter);
+      } else {
+        filterFileRegex = new RegExp(self.filter.substr(0, colonPos));
+        filterNameRegex = new RegExp(self.filter.substr(colonPos + 1));
+      }
+      // This function will first be called with just the filename; if
+      // it returns true the module will be loaded then the function
+      // called again with both the filename and the testname.
+      filter = function(filename, testname) {
+        return filterFileRegex.test(filename) &&
+               ((testname && filterNameRegex) ? filterNameRegex.test(testname)
+                                              : true);
+      };
+    } else
+      filter = function() {return true};
+
+    this.dirs.forEach(
+      function(dir) {
+        var suites = [name.slice(0, -3)
+                      for each (name in file.list(dir).sort())
+                      if (/^test-.*\.js$/.test(name) && filter(name))];
+
+        suites.forEach(
+          function(suite) {
+            var module = require(suite);
+            if (self.testInProcess)
+              for each (let name in Object.keys(module).sort()) {
+                if(NOT_TESTS.indexOf(name) === -1 && filter(suite, name)) {
+                  tests.push({
+                    setup: module.setup,
+                    teardown: module.teardown,
+                    testFunction: self._makeTest(suite, name, module[name]),
+                    name: suite + "." + name
+                  });
+                }
+              }
+          });
+      });
+
+    cb(tests);
+  }
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/unit-test.js b/tools/addon-sdk-1.3/packages/api-utils/lib/unit-test.js
new file mode 100644
index 0000000..ac1c085
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/unit-test.js
@@ -0,0 +1,464 @@
+/* vim:st=2:sts=2:sw=2:
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+var timer = require("./timer");
+
+exports.findAndRunTests = function findAndRunTests(options) {
+  var TestFinder = require("./unit-test-finder").TestFinder;
+  var finder = new TestFinder({
+    dirs: options.dirs,
+    filter: options.filter,
+    testInProcess: options.testInProcess,
+    testOutOfProcess: options.testOutOfProcess
+  });
+  var runner = new TestRunner({fs: options.fs});
+  finder.findTests(
+    function (tests) {
+      runner.startMany({tests: tests,
+                        onDone: options.onDone});
+    });
+};
+
+var TestRunner = exports.TestRunner = function TestRunner(options) {
+  if (options) {
+    this.fs = options.fs;
+  }
+  memory.track(this);
+  this.passed = 0;
+  this.failed = 0;
+  this.testRunSummary = [];
+  this.expectFailNesting = 0;
+};
+
+TestRunner.prototype = {
+  toString: function toString() "[object TestRunner]",
+
+  DEFAULT_PAUSE_TIMEOUT: 10000,
+  PAUSE_DELAY: 500,
+
+  _logTestFailed: function _logTestFailed(why) {
+    this.test.errors[why]++;
+    if (!this.testFailureLogged) {
+      console.error("TEST FAILED: " + this.test.name + " (" + why + ")");
+      this.testFailureLogged = true;
+    }
+  },
+
+  makeSandboxedLoader: function makeSandboxedLoader(options) {
+    if (!this.fs)
+      console.error("Hey, either you didn't pass .fs when building the" +
+                    " TestRunner, or you used 'new' when calling" +
+                    " test.makeSandboxedLoader. Don't do that.");
+
+    if (!options)
+      options = {console: console};
+    options.fs = this.fs;
+
+    var Cuddlefish = require("./cuddlefish");
+
+    if ("moduleOverrides" in options) {
+      var moduleOverrides = options.moduleOverrides;
+      delete options.moduleOverrides;
+      options.getModuleExports = function getModuleExports(basePath, module) {
+        if (module in moduleOverrides)
+          return moduleOverrides[module];
+        return null;
+      }
+    }
+
+    return new Cuddlefish.Loader(options);
+  },
+
+  pass: function pass(message) {
+    if(!this.expectFailure) {
+      console.info("pass:", message);
+      this.passed++;
+      this.test.passed++;
+    }
+    else {
+      this.expectFailure = false;
+      this.fail('Failure Expected: ' + message);
+    }
+  },
+
+  fail: function fail(message) {
+    if(!this.expectFailure) {
+      this._logTestFailed("failure");
+      console.error("fail:", message);
+      console.trace();
+      this.failed++;
+      this.test.failed++;
+    }
+    else {
+      this.expectFailure = false;
+      this.pass(message);
+    }
+  },
+
+  expectFail: function(callback) {
+    this.expectFailure = true;
+    callback();
+    this.expectFailure = false;
+  },
+
+  exception: function exception(e) {
+    this._logTestFailed("exception");
+    console.exception(e);
+    this.failed++;
+    this.test.failed++;
+  },
+
+  assertMatches: function assertMatches(string, regexp, message) {
+    if (regexp.test(string)) {
+      if (!message)
+        message = uneval(string) + " matches " + uneval(regexp);
+      this.pass(message);
+    } else {
+      var no = uneval(string) + " doesn't match " + uneval(regexp);
+      if (!message)
+        message = no;
+      else
+        message = message + " (" + no + ")";
+      this.fail(message);
+    }
+  },
+
+  assertRaises: function assertRaises(func, predicate, message) {
+    try {
+      func();
+      if (message)
+        this.fail(message + " (no exception thrown)");
+      else
+        this.fail("function failed to throw exception");
+    } catch (e) {
+      var errorMessage;
+      if (typeof(e) == "string")
+        errorMessage = e;
+      else
+        errorMessage = e.message;
+      if (typeof(predicate) == "string")
+        this.assertEqual(errorMessage, predicate, message);
+      else
+        this.assertMatches(errorMessage, predicate, message);
+    }
+  },
+
+  assert: function assert(a, message) {
+    if (!a) {
+      if (!message)
+        message = "assertion failed, value is " + a;
+      this.fail(message);
+    } else
+      this.pass(message || "assertion successful");
+  },
+
+  assertNotEqual: function assertNotEqual(a, b, message) {
+    if (a != b) {
+      if (!message)
+        message = "a != b != " + uneval(a);
+      this.pass(message);
+    } else {
+      var equality = uneval(a) + " == " + uneval(b);
+      if (!message)
+        message = equality;
+      else
+        message += " (" + equality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertEqual: function assertEqual(a, b, message) {
+    if (a == b) {
+      if (!message)
+        message = "a == b == " + uneval(a);
+      this.pass(message);
+    } else {
+      var inequality = uneval(a) + " != " + uneval(b);
+      if (!message)
+        message = inequality;
+      else
+        message += " (" + inequality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertNotStrictEqual: function assertNotStrictEqual(a, b, message) {
+    if (a !== b) {
+      if (!message)
+        message = "a !== b !== " + uneval(a);
+      this.pass(message);
+    } else {
+      var equality = uneval(a) + " === " + uneval(b);
+      if (!message)
+        message = equality;
+      else
+        message += " (" + equality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertStrictEqual: function assertStrictEqual(a, b, message) {
+    if (a === b) {
+      if (!message)
+        message = "a === b === " + uneval(a);
+      this.pass(message);
+    } else {
+      var inequality = uneval(a) + " !== " + uneval(b);
+      if (!message)
+        message = inequality;
+      else
+        message += " (" + inequality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertFunction: function assertFunction(a, message) {
+    this.assertStrictEqual('function', typeof a, message);
+  },
+
+  assertUndefined: function(a, message) {
+    this.assertStrictEqual('undefined', typeof a, message);
+  },
+
+  assertNotUndefined: function(a, message) {
+    this.assertNotStrictEqual('undefined', typeof a, message);
+  },
+
+  assertNull: function(a, message) {
+    this.assertStrictEqual(null, a, message);
+  },
+
+  assertNotNull: function(a, message) {
+    this.assertNotStrictEqual(null, a, message);
+  },
+
+  assertObject: function(a, message) {
+    this.assertStrictEqual('[object Object]', Object.prototype.toString.apply(a), message);
+  },
+
+  assertString: function(a, message) {
+    this.assertStrictEqual('[object String]', Object.prototype.toString.apply(a), message);
+  },
+
+  assertArray: function(a, message) {
+    this.assertStrictEqual('[object Array]', Object.prototype.toString.apply(a), message);
+  },
+  
+  assertNumber: function(a, message) {
+    this.assertStrictEqual('[object Number]', Object.prototype.toString.apply(a), message);                
+  },
+
+  done: function done() {
+    if (!this.isDone) {
+      this.isDone = true;
+      if(this.test.teardown) {
+        this.test.teardown(this);
+      }
+      if (this.waitTimeout !== null) {
+        timer.clearTimeout(this.waitTimeout);
+        this.waitTimeout = null;
+      }
+      if (this.test.passed == 0 && this.test.failed == 0) {
+        this._logTestFailed("empty test");
+        this.failed++;
+        this.test.failed++;
+      }
+      
+      this.testRunSummary.push({
+        name: this.test.name,
+        passed: this.test.passed,
+        failed: this.test.failed,
+        errors: [error for (error in this.test.errors)].join(", ")
+      });
+      
+      if (this.onDone !== null) {
+        var onDone = this.onDone;
+        var self = this;
+        this.onDone = null;
+        timer.setTimeout(function() { onDone(self); }, 0);
+      }
+    }
+  },
+  
+  // Set of assertion functions to wait for an assertion to become true
+  // These functions take the same arguments as the TestRunner.assert* methods.
+  waitUntil: function waitUntil() {
+    return this._waitUntil(this.assert, arguments);
+  },
+  
+  waitUntilNotEqual: function waitUntilNotEqual() {
+    return this._waitUntil(this.assertNotEqual, arguments);
+  },
+  
+  waitUntilEqual: function waitUntilEqual() {
+    return this._waitUntil(this.assertEqual, arguments);
+  },
+  
+  waitUntilMatches: function waitUntilMatches() {
+    return this._waitUntil(this.assertMatches, arguments);
+  },
+  
+  /**
+   * Internal function that waits for an assertion to become true.
+   * @param {Function} assertionMethod
+   *    Reference to a TestRunner assertion method like test.assert, 
+   *    test.assertEqual, ...
+   * @param {Array} args
+   *    List of arguments to give to the previous assertion method. 
+   *    All functions in this list are going to be called to retrieve current
+   *    assertion values.
+   */
+  _waitUntil: function waitUntil(assertionMethod, args) {
+    let count = 0;
+    let maxCount = this.DEFAULT_PAUSE_TIMEOUT / this.PAUSE_DELAY;
+    
+    let callback = null;
+    let finished = false;
+    
+    let test = this;
+    function loop() {
+      // Build a mockup object to fake TestRunner API and intercept calls to
+      // pass and fail methods, in order to retrieve nice error messages
+      // and assertion result
+      let mock = {
+        pass: function (msg) {
+          test.pass(msg);
+          if (callback)
+            callback();
+          finished = true;
+        },
+        fail: function (msg) {
+          if (++count > maxCount) {
+            test.fail(msg);
+            if (callback)
+              callback();
+            finished = true;
+            return;
+          }
+          timer.setTimeout(loop, test.PAUSE_DELAY);
+        }
+      };
+      
+      // Automatically call args closures in order to build arguments for 
+      // assertion function
+      let appliedArgs = [];
+      for (let i = 0, l = args.length; i < l; i++) {
+        let a = args[i];
+        if (typeof a == "function") {
+          try {
+            a = a();
+          }
+          catch(e) {
+            test.fail("Exception when calling asynchronous assertion: " + e);
+            finished = true;
+            return;
+          }
+        }
+        appliedArgs.push(a);
+      }
+      
+      // Finally call assertion function with current assertion values
+      assertionMethod.apply(mock, appliedArgs);
+    }
+    loop();
+    
+    // Return an object with `then` method, to offer a way to execute 
+    // some code when the assertion passed or failed
+    return {
+      then: function (c) {
+        callback = c;
+        
+        // In case of immediate positive result, we need to execute callback
+        // immediately here:
+        if (finished)
+          callback();
+      }
+    };
+  },
+  
+  waitUntilDone: function waitUntilDone(ms) {
+    if (ms === undefined)
+      ms = this.DEFAULT_PAUSE_TIMEOUT;
+
+    var self = this;
+
+    function tiredOfWaiting() {
+      self._logTestFailed("timed out");
+      self.failed++;
+      self.test.failed++;
+      self.done();
+    }
+
+    this.waitTimeout = timer.setTimeout(tiredOfWaiting, ms);
+  },
+
+  startMany: function startMany(options) {
+    function runNextTest(self) {
+      var test = options.tests.shift();
+      if (test)
+        self.start({test: test, onDone: runNextTest});
+      else
+        options.onDone(self);
+    }
+    runNextTest(this);
+  },
+
+  start: function start(options) {
+    this.test = options.test;
+    this.test.passed = 0;
+    this.test.failed = 0;
+    this.test.errors = {};
+
+    this.isDone = false;
+    this.onDone = options.onDone;
+    this.waitTimeout = null;
+    this.testFailureLogged = false;
+
+    try {
+      if(this.test.setup) {
+        this.test.setup(this);
+      }
+      this.test.testFunction(this);
+    } catch (e) {
+      this.exception(e);
+    }
+    if (this.waitTimeout === null)
+      this.done();
+  }
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/unload.js b/tools/addon-sdk-1.3/packages/api-utils/lib/unload.js
new file mode 100644
index 0000000..3bbeb38
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/unload.js
@@ -0,0 +1,59 @@
+// Parts of this module were taken from narwhal:
+//
+// http://narwhaljs.org
+
+var observers = [];
+var unloaders = [];
+
+var when = exports.when = function when(observer) {
+  if (observers.indexOf(observer) != -1)
+    return;
+  observers.unshift(observer);
+};
+
+var send = exports.send = function send(reason, onError) {
+  onError = onError || console.exception;
+  observers.forEach(function (observer) {
+    try {
+      observer(reason);
+    } catch (e) {
+      onError(e);
+    }
+  });
+};
+
+var ensure = exports.ensure = function ensure(obj, destructorName) {
+  if (!destructorName)
+    destructorName = "unload";
+  if (!(destructorName in obj))
+    throw new Error("object has no '" + destructorName + "' property");
+
+  let called = false;
+  let originalDestructor = obj[destructorName];
+
+  function unloadWrapper(reason) {
+    if (!called) {
+      called = true;
+      let index = unloaders.indexOf(unloadWrapper);
+      if (index == -1)
+        throw new Error("internal error: unloader not found");
+      unloaders.splice(index, 1);
+      originalDestructor.call(obj, reason);
+      originalDestructor = null;
+      destructorName = null;
+      obj = null;
+    }
+  };
+
+  unloaders.push(unloadWrapper);
+
+  obj[destructorName] = unloadWrapper;
+};
+
+when(
+  function(reason) {
+    unloaders.slice().forEach(
+      function(unloadWrapper) {
+        unloadWrapper(reason);
+      });
+  });
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/url-e10s-adapter.js b/tools/addon-sdk-1.3/packages/api-utils/lib/url-e10s-adapter.js
new file mode 100644
index 0000000..1cc5f59
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/url-e10s-adapter.js
@@ -0,0 +1,93 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Add-on SDK.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *   Myk Melez <myk@mozilla.org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+if (this.chrome) {
+  exports.toFilename   = function(spec) chrome.call("url:toFilename", spec);
+  exports.fromFilename = function(spec) chrome.call("url:fromFilename", spec);
+
+  let URL = exports.URL = function URL(spec, base) {
+    // We have to force the `spec` and `base` arguments, if defined, to be
+    // strings before sending them across the process boundary, since the
+    // boundary will drop their custom toString() methods if they are URL
+    // objects, and the other side depends on being able to convert them to
+    // strings.
+    let result = chrome.call("url:URL",
+                             typeof spec == "undefined" ? spec : "" + spec,
+                             typeof base == "undefined" ? base : "" + base);
+
+    let { scheme, userPass, host, port, path } = result.url;
+
+    return Object.create(URL.prototype, {
+      scheme:   { value: scheme,    enumerable: true },
+      userPass: { value: userPass,  enumerable: true },
+      host:     { value: host,      enumerable: true },
+      port:     { value: port,      enumerable: true },
+      path:     { value: path,      enumerable: true },
+      toString: { value: function() chrome.call("url:toString", result.handle) }
+    });
+  }
+}
+else {
+  const { URL, toFilename, fromFilename } = require("./url");
+
+  exports.register = function register(addon) {
+    addon.registerCall("url:toFilename", function(name, spec) toFilename(spec));
+
+    addon.registerCall("url:fromFilename",
+                       function(name, spec) fromFilename(spec));
+
+    addon.registerCall("url:URL", function(name, spec, base) {
+      let url = URL(spec, base);
+
+      // We create a handle to give the addon process access to the toString()
+      // method, which cannot traverse the process boundary but also can't be
+      // duplicated in the addon process because it accesses private information
+      // (the spec of the URL).  The handle doesn't need to be rooted, as it
+      // can be GCed as soon as all references to it are removed.
+      let handle = addon.createHandle();
+      handle.isRooted = false;
+      handle.url = url;
+
+      return { url: url, handle: handle };
+    });
+
+    addon.registerCall("url:toString",
+                       function(name, handle) handle.url.toString());
+  }
+}
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/url.js b/tools/addon-sdk-1.3/packages/api-utils/lib/url.js
new file mode 100644
index 0000000..4502129
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/url.js
@@ -0,0 +1,123 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci,Cr} = require("chrome");
+
+var ios = Cc['@mozilla.org/network/io-service;1']
+          .getService(Ci.nsIIOService);
+
+var resProt = ios.getProtocolHandler("resource")
+              .QueryInterface(Ci.nsIResProtocolHandler);
+
+function newURI(uriStr, base) {
+  try {
+    let baseURI = base ? ios.newURI(base, null, null) : null;
+    return ios.newURI(uriStr, null, baseURI);
+  }
+  catch (e if e.result == Cr.NS_ERROR_MALFORMED_URI) {
+    throw new Error("malformed URI: " + uriStr);
+  }
+  catch (e if (e.result == Cr.NS_ERROR_FAILURE ||
+               e.result == Cr.NS_ERROR_ILLEGAL_VALUE)) {
+    throw new Error("invalid URI: " + uriStr);
+  }
+}
+
+function resolveResourceURI(uri) {
+  var resolved;
+  try {
+    resolved = resProt.resolveURI(uri);
+  } catch (e if e.result == Cr.NS_ERROR_NOT_AVAILABLE) {
+    throw new Error("resource does not exist: " + uri.spec);
+  };
+  return resolved;
+}
+
+let fromFilename = exports.fromFilename = function fromFilename(path) {
+  var file = Cc['@mozilla.org/file/local;1']
+             .createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  return ios.newFileURI(file).spec;
+};
+
+let toFilename = exports.toFilename = function toFilename(url) {
+  var uri = newURI(url);
+  if (uri.scheme == "resource")
+    uri = newURI(resolveResourceURI(uri));
+  if (uri.scheme == "chrome") {
+    var channel = ios.newChannelFromURI(uri);
+    try {
+      channel = channel.QueryInterface(Ci.nsIFileChannel);
+      return channel.file.path;
+    } catch (e if e.result == Cr.NS_NOINTERFACE) {
+      throw new Error("chrome url isn't on filesystem: " + url);
+    }
+  }
+  if (uri.scheme == "file") {
+    var file = uri.QueryInterface(Ci.nsIFileURL).file;
+    return file.path;
+  }
+  throw new Error("cannot map to filename: " + url);
+};
+
+function URL(url, base) {
+  var uri = newURI(url, base);
+
+  var userPass = null;
+  try {
+    userPass = uri.userPass ? uri.userPass : null;
+  } catch (e if e.result == Cr.NS_ERROR_FAILURE) {}
+
+  var host = null;
+  try {
+    host = uri.host;
+  } catch (e if e.result == Cr.NS_ERROR_FAILURE) {}
+
+  var port = null;
+  try {
+    port = uri.port == -1 ? null : uri.port;
+  } catch (e if e.result == Cr.NS_ERROR_FAILURE) {}
+
+  this.__defineGetter__("scheme", function() uri.scheme);
+  this.__defineGetter__("userPass", function() userPass);
+  this.__defineGetter__("host", function() host);
+  this.__defineGetter__("port", function() port);
+  this.__defineGetter__("path", function() uri.path);
+  this.toString = function URL_toString() uri.spec;
+};
+exports.URL = require("./api-utils").publicConstructor(URL);
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/utils/data.js b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/data.js
new file mode 100644
index 0000000..90a4c04
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/data.js
@@ -0,0 +1,104 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Cc, Ci, Cu } = require("chrome");
+const IOService = Cc["@mozilla.org/network/io-service;1"].
+  getService(Ci.nsIIOService);
+const AppShellService = Cc["@mozilla.org/appshell/appShellService;1"].
+  getService(Ci.nsIAppShellService);
+
+Cu.import("resource://gre/modules/NetUtil.jsm", this);
+const FaviconService = Cc["@mozilla.org/browser/favicon-service;1"].
+                          getService(Ci.nsIFaviconService);
+
+const PNG_B64 = "data:image/png;base64,";
+const DEF_FAVICON_URI = "chrome://mozapps/skin/places/defaultFavicon.png";
+let   DEF_FAVICON = null;
+
+/**
+ * Takes URI of the page and returns associated favicon URI.
+ * If page under passed uri has no favicon then base64 encoded data URI of
+ * default faveicon is returned.
+ * @param {String} uri
+ * @returns {String}
+ */
+exports.getFaviconURIForLocation = function getFaviconURIForLocation(uri) {
+  let pageURI = NetUtil.newURI(uri);
+  try {
+    return FaviconService.getFaviconDataAsDataURL(
+                  FaviconService.getFaviconForPage(pageURI));
+  }
+  catch(e) {
+    if (!DEF_FAVICON) {
+      DEF_FAVICON = PNG_B64 +
+                    base64Encode(getChromeURIContent(DEF_FAVICON_URI));
+    }
+    return DEF_FAVICON;
+  }
+}
+
+/**
+ * Takes chrome URI and returns content under that URI.
+ * @param {String} chromeURI
+ * @returns {String}
+ */
+function getChromeURIContent(chromeURI) {
+  let channel = IOService.newChannel(chromeURI, null, null);
+  let input = channel.open();
+  let stream = Cc["@mozilla.org/binaryinputstream;1"].
+                createInstance(Ci.nsIBinaryInputStream); 
+  stream.setInputStream(input);
+  let content = stream.readBytes(input.available());
+  stream.close();
+  input.close();
+  return content;
+}
+exports.getChromeURIContent = getChromeURIContent;
+
+/**
+ * Creates a base-64 encoded ASCII string from a string of binary data.
+ */
+function base64Encode(data) AppShellService.hiddenDOMWindow.btoa(String(data));
+exports.base64Encode = base64Encode;
+
+/**
+ * Decodes a string of data which has been encoded using base-64 encoding.
+ */
+function base64Decode(data) AppShellService.hiddenDOMWindow.atob(String(data));
+exports.base64Decode = base64Decode;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/utils/function.js b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/function.js
new file mode 100644
index 0000000..ba43d59
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/function.js
@@ -0,0 +1,64 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+var { setTimeout } = require("../timer");
+
+/**
+ * Takes a function and returns a wrapped one instead, calling which will call
+ * original function in the next turn of event loop. This is basically utility
+ * to do `setTimeout(function() { ... }, 0)`, with a difference that returned
+ * function is reused, instead of creating a new one each time. This also allows
+ * to use this functions as event listeners.
+ */
+function Enqueued(callee) {
+  return function enqueued()
+    setTimeout(invoke, 0, callee, arguments, this);
+}
+exports.Enqueued = Enqueued;
+
+/**
+ * Invokes `callee` by passing `params` as an arguments and `self` as `this`
+ * pseudo-variable. Returns value that is returned by a callee.
+ * @param {Function} callee
+ *    Function to invoke.
+ * @param {Array} params
+ *    Arguments to invoke function with.
+ * @param {Object} self
+ *    Object to be passed as a `this` pseudo variable.
+ */
+function invoke(callee, params, self) callee.apply(self, params);
+exports.invoke = invoke;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/utils/registry.js b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/registry.js
new file mode 100644
index 0000000..1d2d8c6
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/registry.js
@@ -0,0 +1,90 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { EventEmitter } = require('../events');
+const unload = require('../unload');
+
+const Registry = EventEmitter.compose({
+  _registry: null,
+  _constructor: null,
+  constructor: function Registry(constructor) {
+    this._registry = [];
+    this._constructor = constructor;
+    this.on('error', this._onError = this._onError.bind(this));
+    unload.ensure(this, "_destructor");
+  },
+  _destructor: function _destructor() {
+    let _registry = this._registry.slice(0);
+    for each (let instance in _registry)
+      this._emit('remove', instance);
+    this._registry.splice(0);
+  },
+  _onError: function _onError(e) {
+    if (!this._listeners('error').length)
+      console.error(e);
+  },
+  has: function has(instance) {
+    let _registry = this._registry;
+    return (
+      (0 <= _registry.indexOf(instance)) ||
+      (instance && instance._public && 0 <= _registry.indexOf(instance._public))
+    );
+  },
+  add: function add(instance) {
+    let { _constructor, _registry } = this; 
+    if (!(instance instanceof _constructor))
+      instance = new _constructor(instance);
+    if (0 > _registry.indexOf(instance)) {
+      _registry.push(instance);
+      this._emit('add', instance);
+      return instance;
+    }
+  },
+  remove: function remove(instance) {
+    let _registry = this._registry;
+    let index = _registry.indexOf(instance)
+    if (0 <= index) {
+      this._emit('remove', instance);
+      _registry.splice(index, 1);
+    }
+  }
+});
+exports.Registry = Registry;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/utils/thumbnail.js b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/thumbnail.js
new file mode 100644
index 0000000..d9012e1
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/utils/thumbnail.js
@@ -0,0 +1,76 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { Cc, Ci, Cu } = require("chrome");
+const AppShellService = Cc["@mozilla.org/appshell/appShellService;1"].
+  getService(Ci.nsIAppShellService);
+
+const NS = "http://www.w3.org/1999/xhtml";
+const COLOR = "rgb(255,255,255)";
+
+/**
+ * Creates canvas element with a thumbnail of the passed window.
+ * @param {Window} window
+ * @returns {Element}
+ */
+function getThumbnailCanvasForWindow(window) {
+  let aspectRatio = 0.5625; // 16:9
+  let thumbnail = AppShellService.hiddenDOMWindow.document
+                    .createElementNS(NS, "canvas");
+  thumbnail.mozOpaque = true;
+  thumbnail.width = Math.ceil(window.screen.availWidth / 5.75);
+  thumbnail.height = Math.round(thumbnail.width * aspectRatio);
+  let ctx = thumbnail.getContext("2d");
+  let snippetWidth = window.innerWidth * .6;
+  let scale = thumbnail.width / snippetWidth;
+  ctx.scale(scale, scale);
+  ctx.drawWindow(window, window.scrollX, window.scrollY, snippetWidth,
+                snippetWidth * aspectRatio, COLOR);
+  return thumbnail;
+}
+exports.getThumbnailCanvasForWindow = getThumbnailCanvasForWindow;
+
+/**
+ * Creates Base64 encoded data URI of the thumbnail for the passed window.
+ * @param {Window} window
+ * @returns {String}
+ */
+exports.getThumbnailURIForWindow = function getThumbnailURIForWindow(window) {
+  return getThumbnailCanvasForWindow(window).toDataURL()
+};
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/window-utils.js b/tools/addon-sdk-1.3/packages/api-utils/lib/window-utils.js
new file mode 100644
index 0000000..20dedfd
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/window-utils.js
@@ -0,0 +1,215 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci} = require("chrome");
+
+var errors = require("./errors");
+
+var gWindowWatcher = Cc["@mozilla.org/embedcomp/window-watcher;1"]
+                     .getService(Ci.nsIWindowWatcher);
+
+const { EventEmitter } = require('./events'),
+      { Trait } = require('./traits');
+
+/**
+ * An iterator for XUL windows currently in the application.
+ * 
+ * @return A generator that yields XUL windows exposing the
+ *         nsIDOMWindow interface.
+ */
+var windowIterator = exports.windowIterator = function windowIterator() {
+  let winEnum = gWindowWatcher.getWindowEnumerator();
+  while (winEnum.hasMoreElements())
+    yield winEnum.getNext().QueryInterface(Ci.nsIDOMWindow);
+};
+
+/**
+ * An iterator for browser windows currently open in the application.
+ * @returns {Function}
+ *    A generator that yields browser windows exposing the `nsIDOMWindow`
+ *    interface.
+ */
+function browserWindowIterator() {
+  for each (let window in windowIterator()) {
+    if (isBrowser(window))
+      yield window;
+  }
+}
+exports.browserWindowIterator = browserWindowIterator;
+
+var WindowTracker = exports.WindowTracker = function WindowTracker(delegate) {
+  this.delegate = delegate;
+  this._loadingWindows = [];
+  for (let window in windowIterator())
+    this._regWindow(window);
+  gWindowWatcher.registerNotification(this);
+  require("./unload").ensure(this);
+};
+
+WindowTracker.prototype = {
+  _regLoadingWindow: function _regLoadingWindow(window) {
+    this._loadingWindows.push(window);
+    window.addEventListener("load", this, true);
+  },
+
+  _unregLoadingWindow: function _unregLoadingWindow(window) {
+    var index = this._loadingWindows.indexOf(window);
+
+    if (index != -1) {
+      this._loadingWindows.splice(index, 1);
+      window.removeEventListener("load", this, true);
+    }
+  },
+
+  _regWindow: function _regWindow(window) {
+    if (window.document.readyState == "complete") {
+      this._unregLoadingWindow(window);
+      this.delegate.onTrack(window);
+    } else
+      this._regLoadingWindow(window);
+  },
+
+  _unregWindow: function _unregWindow(window) {
+    if (window.document.readyState == "complete") {
+      if (this.delegate.onUntrack)
+        this.delegate.onUntrack(window);
+    } else {
+      this._unregLoadingWindow(window);
+    }
+  },
+
+  unload: function unload() {
+    gWindowWatcher.unregisterNotification(this);
+    for (let window in windowIterator())
+      this._unregWindow(window);
+  },
+
+  handleEvent: function handleEvent(event) {
+    if (event.type == "load" && event.target) {
+      var window = event.target.defaultView;
+      if (window)
+        this._regWindow(window);
+    }
+  },
+
+  observe: function observe(subject, topic, data) {
+    var window = subject.QueryInterface(Ci.nsIDOMWindow);
+    if (topic == "domwindowopened")
+      this._regWindow(window);
+    else
+      this._unregWindow(window);
+  }
+};
+
+errors.catchAndLogProps(WindowTracker.prototype, ["handleEvent", "observe"]);
+
+const WindowTrackerTrait = Trait.compose({
+  _onTrack: Trait.required,
+  _onUntrack: Trait.required,
+  constructor: function WindowTrackerTrait() {
+    new WindowTracker({
+      onTrack: this._onTrack.bind(this),
+      onUntrack: this._onUntrack.bind(this)
+    });
+  }
+});
+exports.WindowTrackerTrait = WindowTrackerTrait;
+
+var gDocsToClose = [];
+
+function onDocUnload(event) {
+  var index = gDocsToClose.indexOf(event.target);
+  if (index == -1)
+    throw new Error("internal error: unloading document not found");
+  var document = gDocsToClose.splice(index, 1)[0];
+  // Just in case, let's remove the event listener too.
+  document.defaultView.removeEventListener("unload", onDocUnload, false);
+}
+
+onDocUnload = require("./errors").catchAndLog(onDocUnload);
+
+exports.closeOnUnload = function closeOnUnload(window) {
+  window.addEventListener("unload", onDocUnload, false);
+  gDocsToClose.push(window.document);
+};
+
+exports.__defineGetter__("activeWindow", function() {
+  return Cc["@mozilla.org/appshell/window-mediator;1"]
+         .getService(Ci.nsIWindowMediator)
+         .getMostRecentWindow(null);
+});
+exports.__defineSetter__("activeWindow", function(window) {
+  try {
+    window.focus();
+  }
+  catch (e) { }
+});
+
+exports.__defineGetter__("activeBrowserWindow", function() {
+  return Cc["@mozilla.org/appshell/window-mediator;1"]
+         .getService(Ci.nsIWindowMediator)
+         .getMostRecentWindow("navigator:browser");
+});
+
+/**
+ * Returns the ID of the window's current inner window.
+ */
+exports.getInnerId = function getInnerId(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+                getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
+};
+
+/**
+ * Returns the ID of the window's outer window.
+ */
+exports.getOuterId = function getOuterId(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+                getInterface(Ci.nsIDOMWindowUtils).outerWindowID;
+};
+
+function isBrowser(window) {
+  return window.document.documentElement.getAttribute("windowtype") ===
+         "navigator:browser";
+};
+exports.isBrowser = isBrowser;
+
+require("./unload").when(
+  function() {
+    gDocsToClose.slice().forEach(
+      function(doc) { doc.defaultView.close(); });
+  });
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/windows/dom.js b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/dom.js
new file mode 100644
index 0000000..d74e314
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/dom.js
@@ -0,0 +1,60 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+'use strict';
+
+const { Trait } = require('../traits');
+
+const WindowDom = Trait.compose({
+  _window: Trait.required,
+  get title() {
+    let window = this._window;
+    return window && window.document ? window.document.title : null
+  },
+  close: function close() {
+    let window = this._window;
+    if (window) window.close();
+    return this._public;
+  },
+  activate: function activate() {
+    let window = this._window;
+    if (window) window.focus();
+    return this._public;
+  }
+});
+exports.WindowDom = WindowDom;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/windows/loader.js b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/loader.js
new file mode 100644
index 0000000..635b9e5
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/loader.js
@@ -0,0 +1,151 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { Cc, Ci } = require('chrome'),
+      { setTimeout } = require("../timer"),
+      { Trait } = require('../traits'),
+
+      WM = Cc['@mozilla.org/appshell/window-mediator;1'].
+        getService(Ci.nsIWindowMediator),
+
+      URI_BROWSER = 'chrome://browser/content/browser.xul',
+      NAME = '_blank',
+      FEATURES = 'chrome,all,dialog=no',
+      PARAMS = [ URI_BROWSER, NAME, FEATURES ],
+      ON_LOAD = 'load',
+      ON_UNLOAD = 'unload',
+      STATE_LOADED = 'complete',
+      BROWSER = 'navigator:browser';
+
+/**
+ * Trait provides private `_window` property and requires `_onLoad` property
+ * that will be called when `_window` is loaded. If `_window` property value
+ * is changed with already loaded window `_onLoad` still will be called.
+ */
+const WindowLoader = Trait.compose({
+  /**
+   * Internal listener that is called when window is loaded.
+   * Please keep in mind that this trait will not handle exceptions that may
+   * be thrown by this method so method itself should take care of
+   * handling them.
+   * @param {nsIWindow} window
+   */
+  _onLoad: Trait.required,
+  _tabOptions: Trait.required,
+  /**
+   * Internal listener that is called when `_window`'s DOM 'unload' event
+   * is dispatched. Please note that this trait will not handle exceptions that
+   * may be thrown by this method so method itself should take care of
+   * handling them.
+   */
+  _onUnload: Trait.required,
+  _load: function _load() {
+    if (this.__window) return;
+    let params = PARAMS.slice()
+    params.push(this._tabOptions.map(function(options) options.url).join("|"))
+    let browser =  WM.getMostRecentWindow(BROWSER);
+    this._window = browser.openDialog.apply(browser, params);
+  },
+  /**
+   * Private window who's load event is being tracked. Once window is loaded
+   * `_onLoad` is called.
+   * @type {nsIWindow}
+   */
+  get _window() this.__window,
+  set _window(window) {
+    let _window = this.__window;
+    if (!window) window = null;
+    if (window == _window) return;
+    if (_window) {
+      _window.removeEventListener(ON_UNLOAD, this.__unloadListener, false);
+      _window.removeEventListener(ON_LOAD, this.__loadListener, false);
+    }
+    if (!window) return;
+    window.addEventListener(
+      ON_UNLOAD,
+      this.__unloadListener ||
+        (this.__unloadListener = this._unloadListener.bind(this))
+      ,
+      false
+    );
+    this.__window = window;
+    // If window is not loaded yet setting up a listener.
+    if (STATE_LOADED != window.document.readyState) {
+      window.addEventListener(
+        ON_LOAD,
+        this.__loadListener ||
+          (this.__loadListener = this._loadListener.bind(this))
+        ,
+        false
+      );
+    }
+    else { // If window is loaded calling listener next turn of event loop.
+      this._onLoad(window)
+    }
+    return window;
+  },
+  __window: null,
+  /**
+   * Internal method used for listening 'load' event on the `_window`.
+   * Method takes care of removing itself from 'load' event listeners once
+   * event is being handled.
+   */
+  _loadListener: function _loadListener(event) {
+    let window = this._window;
+    if (!event.target || event.target.defaultView != window) return;
+    window.removeEventListener(ON_LOAD, this.__loadListener, false);
+    this._onLoad(window);
+  },
+  __loadListener: null,
+  /**
+   * Internal method used for listening 'unload' event on the `_window`.
+   * Method takes care of removing itself from 'unload' event listeners once
+   * event is being handled.
+   */
+  _unloadListener: function _unloadListener(event) {
+    let window = this._window;
+    if (!event.target
+      || event.target.defaultView != window
+      || STATE_LOADED != window.document.readyState
+    ) return;
+    window.removeEventListener(ON_UNLOAD, this.__unloadListener, false);
+    this._onUnload(window);
+  },
+  __unloadListener: null
+});
+exports.WindowLoader = WindowLoader;
+
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/windows/observer.js b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/observer.js
new file mode 100644
index 0000000..d7b01e6
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/observer.js
@@ -0,0 +1,86 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const { EventEmitterTrait: EventEmitter } = require("../events");
+const { WindowTracker, windowIterator } = require("../window-utils");
+const { DOMEventAssembler } = require("../events/assembler");
+const { Trait } = require("../light-traits");
+
+// Event emitter objects used to register listeners and emit events on them
+// when they occur.
+const observer = Trait.compose(DOMEventAssembler, EventEmitter).create({
+  /**
+   * Method is implemented by `EventEmitter` and is used just for emitting
+   * events on registered listeners.
+   */
+  _emit: Trait.required,
+  /**
+   * Events that are supported and emitted by the module.
+   */
+  supportedEventsTypes: [ "activate", "deactivate" ],
+  /**
+   * Function handles all the supported events on all the windows that are
+   * observed. Method is used to proxy events to the listeners registered on
+   * this event emitter.
+   * @param {Event} event
+   *    Keyboard event being emitted.
+   */
+  handleEvent: function handleEvent(event) {
+    this._emit(event.type, event.target, event);
+  }
+});
+
+// Using `WindowTracker` to track window events.
+new WindowTracker({
+  onTrack: function onTrack(chromeWindow) {
+    observer._emit("open", chromeWindow);
+    observer.observe(chromeWindow);
+  },
+  onUntrack: function onUntrack(chromeWindow) {
+    observer._emit("close", chromeWindow);
+    observer.ignore(chromeWindow);
+  }
+});
+
+// Making observer aware of already opened windows.
+for each (let window in windowIterator())
+  observer.observe(window);
+
+exports.observer = observer;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/windows/tabs.js b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/tabs.js
new file mode 100644
index 0000000..551b1ce
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/windows/tabs.js
@@ -0,0 +1,207 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is
+ * the Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Irakli Gozalishvili <gozala@mozilla.com> (Original Author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+"use strict";
+
+const { Trait } = require("../traits");
+const { List } = require("../list");
+const { Tab, Options } = require("../tabs/tab");
+const { EventEmitter } = require("../events");
+const { EVENTS } = require("../tabs/events");
+const { getOwnerWindow, getActiveTab, getTabs,
+        openTab, activateTab } = require("../tabs/utils");
+const { observer: tabsObserver } = require("../tabs/observer");
+
+const TAB_BROWSER = "tabbrowser";
+
+/**
+ * This is a trait that is used in composition of window wrapper. Trait tracks
+ * tab related events of the wrapped window in order to keep track of open
+ * tabs and maintain their wrappers. Every new tab gets wrapped and jetpack
+ * type event is emitted.
+ */
+const WindowTabTracker = Trait.compose({
+  /**
+   * Chrome window whose tabs are tracked.
+   */
+  _window: Trait.required,
+  /**
+   * Function used to emit events.
+   */
+  _emit: EventEmitter.required,
+  _tabOptions: Trait.required,
+  /**
+   * Function to add event listeners.
+   */
+  on: EventEmitter.required,
+  removeListener: EventEmitter.required,
+  /**
+   * Initializes tab tracker for a browser window.
+   */
+  _initWindowTabTracker: function _initWindowTabTracker() {
+    // Ugly hack that we have to remove at some point (see Bug 658059). At this
+    // point it is necessary to invoke lazy `tabs` getter on the windows object
+    // which creates a `TabList` instance.
+    this.tabs;
+    // Binding all methods used as event listeners to the instance.
+    this._onTabReady = this._emitEvent.bind(this, "ready");
+    this._onTabOpen = this._onTabEvent.bind(this, "open");
+    this._onTabClose = this._onTabEvent.bind(this, "close");
+    this._onTabActivate = this._onTabEvent.bind(this, "activate");
+    this._onTabDeactivate = this._onTabEvent.bind(this, "deactivate");
+
+    for each (let tab in getTabs(this._window)) {
+      // We emulate "open" events for all open tabs since gecko does not emits
+      // them on the tabs that new windows are open with. Also this is
+      // necessary to synchronize tabs lists with an actual state.
+      this._onTabOpen(tab);
+    }
+    // We also emulate "activate" event so that it's picked up by a tab list.
+    this._onTabActivate(getActiveTab(this._window));
+
+    // Setting up event listeners
+    tabsObserver.on("open", this._onTabOpen);
+    tabsObserver.on("close", this._onTabClose);
+    tabsObserver.on("activate", this._onTabActivate);
+    tabsObserver.on("deactivate", this._onTabDeactivate);
+  },
+  _destroyWindowTabTracker: function _destroyWindowTabTracker() {
+    // We emulate close events on all tabs, since gecko does not emits such
+    // events by itself.
+    for each (let tab in this.tabs)
+      this._emitEvent("close", tab);
+
+    this._tabs._clear();
+
+    tabsObserver.removeListener("open", this._onTabOpen);
+    tabsObserver.removeListener("close", this._onTabClose);
+    tabsObserver.removeListener("activate", this._onTabActivate);
+    tabsObserver.removeListener("deactivate", this._onTabDeactivate);
+  },
+  _onTabEvent: function _onTabEvent(type, tab) {
+    if (this._window === getOwnerWindow(tab)) {
+      let options = this._tabOptions.shift() || {};
+      options.tab = tab;
+      options.window = this._public;
+      // creating tab wrapper and adding listener to "ready" events.
+      let wrappedTab = Tab(options);
+
+      // Setting up an event listener for ready events.
+      if (type === "open")
+        wrappedTab.on("ready", this._onTabReady);
+
+      this._emitEvent(type, wrappedTab);
+    }
+  },
+  _emitEvent: function _emitEvent(type, tab) {
+    // Notifies combined tab list that tab was added / removed.
+    tabs._emit(type, tab);
+    // Notifies contained tab list that window was added / removed.
+    this._tabs._emit(type, tab);
+  }
+});
+exports.WindowTabTracker = WindowTabTracker;
+
+/**
+ * This trait is used to create live representation of open tab lists. Each
+ * window wrapper's tab list is represented by an object created from this
+ * trait. It is also used to represent list of all the open windows. Trait is
+ * composed out of `EventEmitter` in order to emit 'TabOpen', 'TabClose' events.
+ * **Please note** that objects created by this trait can't be exposed outside
+ * instead you should expose it's `_public` property, see comments in
+ * constructor for details.
+ */
+const TabList = List.resolve({ constructor: "_init" }).compose(
+  // This is ugly, but necessary. Will be removed by #596248
+  EventEmitter.resolve({ toString: null }),
+  Trait.compose({
+    on: Trait.required,
+    _emit: Trait.required,
+    constructor: function TabList(options) {
+      this._window = options.window;
+      // Add new items to the list
+      this.on(EVENTS.open.name, this._add.bind(this));
+      // Remove closed items from the list
+      this.on(EVENTS.close.name, this._remove.bind(this));
+
+      // Set value whenever new tab becomes active.
+      this.on("activate", function onTabActivate(tab) {
+        this._activeTab = tab;
+      }.bind(this));
+      // Initialize list.
+      this._init();
+      // This list is not going to emit any events, object holding this list
+      // will do it instead, to make that possible we return a private API.
+      return this;
+    },
+    get activeTab() this._activeTab,
+    _activeTab: null,
+
+    open: function open(options) {
+      options = Options(options);
+      this._window._tabOptions.push(options);
+      let tab = openTab(this._window._window, options.url);
+      if (!options.inBackground)
+        activateTab(tab);
+    }
+  // This is ugly, but necessary. Will be removed by #596248
+  }).resolve({ toString: null })
+);
+
+/**
+ * Combined list of all open tabs on all the windows.
+ * type {TabList}
+ */
+var tabs = TabList({ window: null });
+exports.tabs = tabs._public;
+
+/**
+ * Trait is a part of composition that represents window wrapper. This trait is
+ * composed out of `WindowTabTracker` that allows it to keep track of open tabs
+ * on the window being wrapped.
+ */
+const WindowTabs = Trait.compose(
+  WindowTabTracker,
+  Trait.compose({
+    _window: Trait.required,
+    /**
+     * List of tabs
+     */
+    get tabs() (this._tabs || (this._tabs = TabList({ window: this })))._public,
+    _tabs: null,
+  })
+);
+exports.WindowTabs = WindowTabs;
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/xhr.js b/tools/addon-sdk-1.3/packages/api-utils/lib/xhr.js
new file mode 100644
index 0000000..10b83db
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/xhr.js
@@ -0,0 +1,181 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci} = require("chrome");
+
+// ## Implementation Notes ##
+// 
+// Making `XMLHttpRequest` objects available to Jetpack code involves a
+// few key principles universal to all low-level module implementations:
+//
+// * **Unloadability**. A Jetpack-based extension using this module can be 
+//   asked to unload itself at any time, e.g. because the user decides to
+//   uninstall or disable the extension. This means we need to keep track of
+//   all in-progress reqests and abort them on unload.
+//
+// * **Developer-Ergonomic Tracebacks**. Whenever an exception is raised
+//   by a Jetpack-based extension, we want it to be logged in a
+//   place that is specific to that extension--so that a developer
+//   can distinguish it from an error on a web page or in another
+//   extension, for instance. We also want it to be logged with a
+//   full stack traceback, which the Mozilla platform doesn't usually
+//   do.
+//
+//   Because of this, we don't actually want to give the Mozilla
+//   platform's "real" XHR implementation to clients, but instead provide
+//   a simple wrapper that trivially delegates to the implementation in
+//   all cases except where callbacks are involved: whenever Mozilla
+//   platform code calls into the extension, such as during the XHR's
+//   `onreadystatechange` callback, we want to wrap the client's callback
+//   in a try-catch clause that traps any exceptions raised by the
+//   callback and logs them via console.exception() instead of allowing
+//   them to propagate back into Mozilla platform code.
+
+// This is a private list of all active requests, so we know what to
+// abort if we're asked to unload.
+var requests = [];
+
+// Events on XHRs that we should listen for, so we know when to remove
+// a request from our private list.
+const TERMINATE_EVENTS = ["load", "error", "abort"];
+
+// Read-only properties of XMLHttpRequest objects that we want to
+// directly delegate to.
+const READ_ONLY_PROPS = ["readyState", "responseText", "responseXML",
+                         "status", "statusText"];
+
+// Methods of XMLHttpRequest that we want to directly delegate to.
+const DELEGATED_METHODS = ["abort", "getAllResponseHeaders",
+                           "getResponseHeader", "overrideMimeType",
+                           "send", "sendAsBinary", "setRequestHeader",
+                           "open"];
+
+var getRequestCount = exports.getRequestCount = function getRequestCount() {
+  return requests.length;
+};
+
+var XMLHttpRequest = exports.XMLHttpRequest = function XMLHttpRequest() {
+  var req = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
+            .createInstance(Ci.nsIXMLHttpRequest);
+  // For the sake of simplicity, don't tie this request to any UI.
+  req.mozBackgroundRequest = true;
+
+  memory.track(req, "XMLHttpRequest");
+
+  this._req = req;
+  this._orsc = null;
+
+  requests.push(this);
+
+  var self = this;
+
+  this._boundCleanup = function _boundCleanup() {
+    self._cleanup();
+  };
+
+  TERMINATE_EVENTS.forEach(
+    function(name) {
+      self._req.addEventListener(name, self._boundCleanup, false);
+    });
+};
+
+XMLHttpRequest.prototype = {
+  _cleanup: function _cleanup() {
+    this.onreadystatechange = null;
+    var index = requests.indexOf(this);
+    if (index != -1) {
+      var self = this;
+      TERMINATE_EVENTS.forEach(
+        function(name) {
+          self._req.removeEventListener(name, self._boundCleanup, false);
+        });
+      requests.splice(index, 1);
+    }
+  },
+  _unload: function _unload() {
+    this._req.abort();
+    this._cleanup();
+  },
+  addEventListener: function addEventListener() {
+    throw new Error("not implemented");
+  },
+  removeEventListener: function removeEventListener() {
+    throw new Error("not implemented");
+  },
+  set upload(newValue) {
+    throw new Error("not implemented");
+  },
+  get onreadystatechange() {
+    return this._orsc;
+  },
+  set onreadystatechange(cb) {
+    this._orsc = cb;
+    if (cb) {
+      var self = this;
+      this._req.onreadystatechange = function() {
+        try {
+          self._orsc.apply(self, arguments);
+        } catch (e) {
+          console.exception(e);
+        }
+      };
+    } else
+      this._req.onreadystatechange = null;
+  }
+};
+
+READ_ONLY_PROPS.forEach(
+   function(name) {
+     XMLHttpRequest.prototype.__defineGetter__(
+       name,
+       function() {
+         return this._req[name];
+       });
+   });
+
+DELEGATED_METHODS.forEach(
+  function(name) {
+    XMLHttpRequest.prototype[name] = function() {
+      return this._req[name].apply(this._req, arguments);
+    };
+  });
+
+require("./unload").when(
+  function() {
+    requests.slice().forEach(function(request) { request._unload(); });
+  });
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/xpcom.js b/tools/addon-sdk-1.3/packages/api-utils/lib/xpcom.js
new file mode 100644
index 0000000..10f1d6b
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/xpcom.js
@@ -0,0 +1,152 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *   Drew Willcoxon <adw@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc,Ci,Cm,Cr,Cu} = require("chrome");
+
+var jsm = {};
+Cu.import("resource://gre/modules/XPCOMUtils.jsm", jsm);
+var utils = exports.utils = jsm.XPCOMUtils;
+
+Cm.QueryInterface(Ci.nsIComponentRegistrar);
+
+var factories = [];
+
+function Factory(options) {
+  memory.track(this);
+
+  this.wrappedJSObject = this;
+  this.create = options.create;
+  this.uuid = options.uuid;
+  this.name = options.name;
+  this.contractID = options.contractID;
+
+  Cm.registerFactory(this.uuid,
+                     this.name,
+                     this.contractID,
+                     this);
+
+  var self = this;
+
+  factories.push(this);
+}
+
+Factory.prototype = {
+  createInstance: function(outer, iid) {
+    try {
+      if (outer)
+        throw Cr.NS_ERROR_NO_AGGREGATION;
+      return (new this.create()).QueryInterface(iid);
+    } catch (e) {
+      console.exception(e);
+      if (e instanceof Ci.nsIException)
+        throw e;
+      else
+        throw Cr.NS_ERROR_FAILURE;
+    }
+  },
+  unregister: function() {
+    var index = factories.indexOf(this);
+    if (index == -1)
+      throw new Error("factory already unregistered");
+
+    var self = this;
+
+    factories.splice(index, 1);
+    Cm.unregisterFactory(this.uuid, this);
+  },
+  QueryInterface: utils.generateQI([Ci.nsIFactory])
+};
+
+var makeUuid = exports.makeUuid = function makeUuid() {
+  var uuidGenerator = Cc["@mozilla.org/uuid-generator;1"]
+                      .getService(Ci.nsIUUIDGenerator);
+  var uuid = uuidGenerator.generateUUID();
+  return uuid;
+};
+
+var autoRegister = exports.autoRegister = function autoRegister(path) {
+  // TODO: This assumes that the url points to a directory
+  // that contains subdirectories corresponding to OS/ABI and then
+  // further subdirectories corresponding to Gecko platform version.
+  // we should probably either behave intelligently here or allow
+  // the caller to pass-in more options if e.g. there aren't
+  // Gecko-specific binaries for a component (which will be the case
+  // if only frozen interfaces are used).
+
+  var appInfo = Cc["@mozilla.org/xre/app-info;1"]
+                .getService(Ci.nsIXULAppInfo);
+  var runtime = Cc["@mozilla.org/xre/app-info;1"]
+                .getService(Ci.nsIXULRuntime);
+
+  var osDirName = runtime.OS + "_" + runtime.XPCOMABI;
+  var platformVersion = appInfo.platformVersion.substring(0, 5);
+
+  var file = Cc['@mozilla.org/file/local;1']
+             .createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  file.append(osDirName);
+  file.append(platformVersion);
+
+  if (!(file.exists() && file.isDirectory()))
+    throw new Error("component not available for OS/ABI " +
+                    osDirName + " and platform " + platformVersion);
+
+  Cm.QueryInterface(Ci.nsIComponentRegistrar);
+  Cm.autoRegister(file);
+};
+
+var register = exports.register = function register(options) {
+  options = {__proto__: options};
+  if (!options.uuid)
+    options.uuid = makeUuid();
+  return new Factory(options);
+};
+
+var getClass = exports.getClass = function getClass(contractID, iid) {
+  if (!iid)
+    iid = Ci.nsISupports;
+  return Cm.getClassObjectByContractID(contractID, iid);
+};
+
+require("./unload").when(
+  function() {
+    var copy = factories.slice();
+    copy.reverse();
+    copy.forEach(function(factory) { factory.unregister(); });
+  });
diff --git a/tools/addon-sdk-1.3/packages/api-utils/lib/xul-app.js b/tools/addon-sdk-1.3/packages/api-utils/lib/xul-app.js
new file mode 100644
index 0000000..83dd27c
--- /dev/null
+++ b/tools/addon-sdk-1.3/packages/api-utils/lib/xul-app.js
@@ -0,0 +1,93 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Jetpack.
+ *
+ * The Initial Developer of the Original Code is Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2007
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Atul Varma <atul@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+"use strict";
+
+const {Cc, Ci} = require("chrome");
+
+var appInfo = Cc["@mozilla.org/xre/app-info;1"]
+              .getService(Ci.nsIXULAppInfo);
+
+var ID = exports.ID = appInfo.ID;
+var name = exports.name = appInfo.name;
+var version = exports.version = appInfo.version;
+var platformVersion = exports.platformVersion = appInfo.platformVersion;
+
+// The following mapping of application names to GUIDs was taken from:
+// 
+//   https://addons.mozilla.org/en-US/firefox/pages/appversions
+//
+// Using the GUID instead of the app's name is preferable because sometimes
+// re-branded versions of a product have different names: for instance,
+// Firefox, Minefield, Iceweasel, and Shiretoko all have the same
+// GUID.
+
+var ids = exports.ids = {
+  Firefox: "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}",
+  Mozilla: "{86c18b42-e466-45a9-ae7a-9b95ba6f5640}",
+  Sunbird: "{718e30fb-e89b-41dd-9da7-e25a45638b28}",
+  SeaMonkey: "{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}",
+  Fennec: "{a23983c0-fd0e-11dc-95ff-0800200c9a66}",
+  Thunderbird: "{3550f703-e582-4d05-9a08-453d09bdfdc6}"
+};
+
+var is = exports.is = function is(name) {
+  if (!(name in ids))
+    throw new Error("Unkown Mozilla Application: " + name);
+  return ID == ids[name];
+};
+
+var isOneOf = exports.isOneOf = function isOneOf(names) {
+  for (var i = 0; i < names.length; i++)
+    if (is(names[i]))
+      return true;
+  return false;
+};
+
+/**
+ * Use this to check whether the given version (e.g. xulApp.platformVersion)
+ * is in the given range. Versions must be in version comparator-compatible
+ * format. See MDC for details:
+ * https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsIVersionComparator
+ */
+var versionInRange = exports.versionInRange =
+function versionInRange(version, lowInclusive, highExclusive) {
+  var vc = Cc["@mozilla.org/xpcom/version-comparator;1"]
+           .getService(Ci.nsIVersionComparator);
+  return (vc.compare(version, lowInclusive) >= 0) &&
+         (vc.compare(version, highExclusive) < 0);
+}
+