6 files changed, 393 insertions, 0 deletions
diff --git a/tools/addon-sdk-1.12/lib/sdk/system/environment.js b/tools/addon-sdk-1.12/lib/sdk/system/environment.js
new file mode 100644
index 0000000..045bab1
--- /dev/null
+++ b/tools/addon-sdk-1.12/lib/sdk/system/environment.js
@@ -0,0 +1,58 @@
+/* vim:set ts=2 sw=2 sts=2 expandtab */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { Cc, Ci } = require('chrome');
+const { get, set, exists } = Cc['@mozilla.org/process/environment;1'].
+                             getService(Ci.nsIEnvironment);
+
+exports.env = Proxy.create({
+  // XPCOM does not provides a way to enumerate environment variables, so we
+  // just don't support enumeration.
+  getPropertyNames: function() [],
+  getOwnPropertyNames: function() [],
+  enumerate: function() [],
+  keys: function() [],
+  // We do not support freezing, cause it would make it impossible to set new
+  // environment variables.
+  fix: function() undefined,
+  // We present all environment variables as own properties of this object,
+  // so we just delegate this call to `getOwnPropertyDescriptor`.
+  getPropertyDescriptor: function(name) this.getOwnPropertyDescriptor(name),
+  // If environment variable with this name is defined, we generate proprety
+  // descriptor for it, otherwise fall back to `undefined` so that for consumer
+  // this property does not exists.
+  getOwnPropertyDescriptor: function(name) {
+    return !exists(name) ? undefined : {
+      value: get(name),
+      enumerable: false,    // Non-enumerable as we don't support enumeration.
+      configurable: true,   // Configurable as it may be deleted.
+      writable: true        // Writable as we do support set.
+    }
+  },
+
+  // New environment variables can be defined just by defining properties
+  // on this object.
+  defineProperty: function(name, { value }) set(name, value),
+  delete: function(name) set(name, null),
+
+  // We present all properties as own, there for we just delegate to `hasOwn`.
+  has: function(name) this.hasOwn(name),
+  // We do support checks for existence of an environment variable, via `in`
+  // operator on this object.
+  hasOwn: function(name) exists(name),
+
+  // On property get / set we do read / write appropriate environment variables,
+  // please note though, that variables with names of standard object properties
+  // intentionally (so that this behaves as normal object) can not be
+  // read / set.
+  get: function(proxy, name) Object.prototype[name] || get(name) || undefined,
+  set: function(proxy, name, value) Object.prototype[name] || set(name, value)
+});
diff --git a/tools/addon-sdk-1.12/lib/sdk/system/events.js b/tools/addon-sdk-1.12/lib/sdk/system/events.js
new file mode 100644
index 0000000..a75dddc
--- /dev/null
+++ b/tools/addon-sdk-1.12/lib/sdk/system/events.js
@@ -0,0 +1,113 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require('chrome');
+const { Unknown } = require('../platform/xpcom');
+const { Class } = require('../core/heritage');
+const { ns } = require('../core/namespace');
+const { addObserver, removeObserver, notifyObservers } = 
+  Cc["@mozilla.org/observer-service;1"].getService(Ci.nsIObserverService);
+
+const Subject = Class({
+  extends: Unknown,
+  initialize: function initialize(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
+    };
+  },
+  getHelperForLanguage: function() {},
+  getInterfaces: function() {}
+});
+
+function emit(type, event) {
+  let subject = 'subject' in event ? Subject(event.subject) : null;
+  let data = 'data' in event ? event.data : null;
+  notifyObservers(subject, type, data);
+}
+exports.emit = emit;
+
+const Observer = Class({
+  extends: Unknown,
+  initialize: function initialize(listener) {
+    this.listener = listener;
+  },
+  interfaces: [ 'nsIObserver', '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 {
+      this.listener({
+        type: topic,
+        subject: subject,
+        data: data
+      });
+    }
+    catch (error) {
+      console.exception(error);
+    }
+  }
+});
+
+const subscribers = ns();
+
+function on(type, listener, strong) {
+  // Unless last optional argument is `true` we use a weak reference to a
+  // listener.
+  let weak = !strong;
+  // Take list of observers associated with given `listener` function.
+  let observers = subscribers(listener);
+  // If `observer` for the given `type` is not registered yet, then
+  // associate an `observer` and register it.
+  if (!(type in observers)) {
+    let observer = Observer(listener);
+    observers[type] = observer;
+    addObserver(observer, type, weak);
+  }
+}
+exports.on = on;
+
+function once(type, listener) {
+  // Note: this code assumes order in which listeners are called, which is fine
+  // as long as dispatch happens in same order as listener registration which
+  // is the case now. That being said we should be aware that this may break
+  // in a future if order will change.
+  on(type, listener);
+  on(type, function cleanup() {
+    off(type, listener);
+    off(type, cleanup);
+  }, true);
+}
+exports.once = once;
+
+function off(type, listener) {
+  // Take list of observers as with the given `listener`.
+  let observers = subscribers(listener);
+  // If `observer` for the given `type` is registered, then
+  // remove it & unregister.
+  if (type in observers) {
+    let observer = observers[type];
+    delete observers[type];
+    removeObserver(observer, type);
+  }
+}
+exports.off = off;
diff --git a/tools/addon-sdk-1.12/lib/sdk/system/globals.js b/tools/addon-sdk-1.12/lib/sdk/system/globals.js
new file mode 100644
index 0000000..df77295
--- /dev/null
+++ b/tools/addon-sdk-1.12/lib/sdk/system/globals.js
@@ -0,0 +1,54 @@
+/* vim:set ts=2 sw=2 sts=2 expandtab */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+let { Cc, Ci, CC } = require('chrome');
+let { PlainTextConsole } = require('../console/plain-text');
+let { stdout } = require('../system');
+let ScriptError = CC('@mozilla.org/scripterror;1', 'nsIScriptError');
+let consoleService = Cc['@mozilla.org/consoleservice;1'].getService().
+                     QueryInterface(Ci.nsIConsoleService);
+
+// On windows dump does not writes into stdout so cfx can't read thous dumps.
+// To workaround this issue we write to a special file from which cfx will
+// read and print to the console.
+// For more details see: bug-673383
+exports.dump = stdout.write;
+
+// Bug 718230: We need to send console messages to stdout and JS Console
+function forsakenConsoleDump(msg, level) {
+  stdout.write(msg);
+
+  if (level === 'error') {
+    let error = ScriptError();
+    msg = msg.replace(/^error: /, '');
+    error.init(msg, null, null, 0, 0, 0, 'Add-on SDK');
+    consoleService.logMessage(error);
+  }
+  else
+    consoleService.logStringMessage(msg);
+};
+exports.console = new PlainTextConsole(forsakenConsoleDump);
+
+// Provide CommonJS `define` to allow authoring modules in a format that can be
+// loaded both into jetpack and into browser via AMD loaders.
+Object.defineProperty(exports, 'define', {
+  // `define` is provided as a lazy getter that binds below defined `define`
+  // function to the module scope, so that require, exports and module
+  // variables remain accessible.
+  configurable: true,
+  get: function() {
+    let sandbox = this;
+    return function define(factory) {
+      factory = Array.slice(arguments).pop();
+      factory.call(sandbox, sandbox.require, sandbox.exports, sandbox.module);
+    }
+  }
+});
diff --git a/tools/addon-sdk-1.12/lib/sdk/system/runtime.js b/tools/addon-sdk-1.12/lib/sdk/system/runtime.js
new file mode 100644
index 0000000..e64b663
--- /dev/null
+++ b/tools/addon-sdk-1.12/lib/sdk/system/runtime.js
@@ -0,0 +1,19 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+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.12/lib/sdk/system/unload.js b/tools/addon-sdk-1.12/lib/sdk/system/unload.js
new file mode 100644
index 0000000..4d2575b
--- /dev/null
+++ b/tools/addon-sdk-1.12/lib/sdk/system/unload.js
@@ -0,0 +1,82 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Parts of this module were taken from narwhal:
+//
+// http://narwhaljs.org
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { on, off } = require('./events');
+const unloadSubject = require('@loader/unload');
+
+const observers = [];
+const unloaders = [];
+
+var when = exports.when = function when(observer) {
+  if (observers.indexOf(observer) != -1)
+    return;
+  observers.unshift(observer);
+};
+
+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;
+    }
+  };
+
+  // TODO: Find out why the order is inverted here. It seems that
+  // it may be causing issues!
+  unloaders.push(unloadWrapper);
+
+  obj[destructorName] = unloadWrapper;
+};
+
+function unload(reason) {
+  observers.forEach(function(observer) {
+    try {
+      observer(reason);
+    }
+    catch (error) {
+      console.exception(error);
+    }
+  });
+}
+
+when(function(reason) {
+  unloaders.slice().forEach(function(unloadWrapper) {
+    unloadWrapper(reason);
+  });
+});
+
+on('sdk:loader:destroy', function onunload({ subject, data: reason }) {
+  // If this loader is unload then `subject.wrappedJSObject` will be
+  // `destructor`.
+  if (subject.wrappedJSObject === unloadSubject) {
+    off('sdk:loader:destroy', onunload);
+    unload(reason);
+  }
+// Note that we use strong reference to listener here to make sure it's not
+// GC-ed, which may happen otherwise since nothing keeps reference to `onunolad`
+// function.
+}, true);
diff --git a/tools/addon-sdk-1.12/lib/sdk/system/xul-app.js b/tools/addon-sdk-1.12/lib/sdk/system/xul-app.js
new file mode 100644
index 0000000..6e8b4e8
--- /dev/null
+++ b/tools/addon-sdk-1.12/lib/sdk/system/xul-app.js
@@ -0,0 +1,67 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+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.
+// This mapping is duplicated in `app-extensions/bootstrap.js`. They should keep
+// in sync, so if you change one, change the other too!
+
+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: "{aa3c5121-dab2-40e2-81ca-7ea25febc110}",
+  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);
+}
+