--- a/addon-sdk/source/lib/sdk/content/content.js
+++ b/addon-sdk/source/lib/sdk/content/content.js
@@ -3,11 +3,11 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 
 module.metadata = {
   "stability": "unstable"
 };
 
 exports.Loader = require('./loader').Loader;
-exports.Symbiont = require('./symbiont').Symbiont;
+exports.Symbiont = require('../deprecated/symbiont').Symbiont;
 exports.Worker = require('./worker').Worker;
 

new file mode 100644
--- /dev/null
+++ b/addon-sdk/source/lib/sdk/content/sandbox.js
@@ -0,0 +1,404 @@
+/* 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 { Class } = require('../core/heritage');
+const { EventTarget } = require('../event/target');
+const { on, off, emit } = require('../event/core');
+const {
+  requiresAddonGlobal,
+  attach, detach, destroy
+} = require('./utils');
+const { delay: async } = require('../lang/functional');
+const { Ci, Cu, Cc } = require('chrome');
+const timer = require('../timers');
+const { URL } = require('../url');
+const { sandbox, evaluate, load } = require('../loader/sandbox');
+const { merge } = require('../util/object');
+const xulApp = require('../system/xul-app');
+const USE_JS_PROXIES = !xulApp.versionInRange(xulApp.platformVersion,
+                                              '17.0a2', '*');
+const { getTabForContentWindow } = require('../tabs/utils');
+
+// WeakMap of sandboxes so we can access private values
+const sandboxes = new WeakMap();
+
+/* Trick the linker in order to ensure shipping these files in the XPI.
+  require('./content-worker.js');
+  Then, retrieve URL of these files in the XPI:
+*/
+let prefix = module.uri.split('sandbox.js')[0];
+const CONTENT_WORKER_URL = prefix + 'content-worker.js';
+
+// Fetch additional list of domains to authorize access to for each content
+// script. It is stored in manifest `metadata` field which contains
+// package.json data. This list is originaly defined by authors in
+// `permissions` attribute of their package.json addon file.
+const permissions = require('@loader/options').metadata['permissions'] || {};
+const EXPANDED_PRINCIPALS = permissions['cross-domain-content'] || [];
+
+const JS_VERSION = '1.8';
+
+const WorkerSandbox = Class({
+
+  implements: [
+    EventTarget
+  ],
+  
+  /**
+   * Emit a message to the worker content sandbox
+   */
+  emit: function emit(...args) {
+    // Ensure having an asynchronous behavior
+    let self = this;
+    async(function () {
+      emitToContent(self, JSON.stringify(args, replacer));
+    });
+  },
+
+  /**
+   * Synchronous version of `emit`.
+   * /!\ Should only be used when it is strictly mandatory /!\
+   *     Doesn't ensure passing only JSON values.
+   *     Mainly used by context-menu in order to avoid breaking it.
+   */
+  emitSync: function emitSync(...args) {
+    return emitToContent(this, args);
+  },
+
+  /**
+   * Tells if content script has at least one listener registered for one event,
+   * through `self.on('xxx', ...)`.
+   * /!\ Shouldn't be used. Implemented to avoid breaking context-menu API.
+   */
+  hasListenerFor: function hasListenerFor(name) {
+    return modelFor(this).hasListenerFor(name);
+  },
+
+  /**
+   * Configures sandbox and loads content scripts into it.
+   * @param {Worker} worker
+   *    content worker
+   */
+  initialize: function WorkerSandbox(worker, window) {
+    let model = {};
+    sandboxes.set(this, model);
+    model.worker = worker;
+    // We receive a wrapped window, that may be an xraywrapper if it's content
+    let proto = window;
+
+    // TODO necessary?
+    // Ensure that `emit` has always the right `this`
+    this.emit = this.emit.bind(this);
+    this.emitSync = this.emitSync.bind(this);
+
+    // Eventually use expanded principal sandbox feature, if some are given.
+    //
+    // But prevent it when the Worker isn't used for a content script but for
+    // injecting `addon` object into a Panel, Widget, ... scope.
+    // That's because:
+    // 1/ It is useless to use multiple domains as the worker is only used
+    // to communicate with the addon,
+    // 2/ By using it it would prevent the document to have access to any JS
+    // value of the worker. As JS values coming from multiple domain principals
+    // can't be accessed by 'mono-principals' (principal with only one domain).
+    // Even if this principal is for a domain that is specified in the multiple
+    // domain principal.
+    let principals = window;
+    let wantGlobalProperties = [];
+    if (EXPANDED_PRINCIPALS.length > 0 && !requiresAddonGlobal(worker)) {
+      principals = EXPANDED_PRINCIPALS.concat(window);
+      // We have to replace XHR constructor of the content document
+      // with a custom cross origin one, automagically added by platform code:
+      delete proto.XMLHttpRequest;
+      wantGlobalProperties.push('XMLHttpRequest');
+    }
+
+    // Instantiate trusted code in another Sandbox in order to prevent content
+    // script from messing with standard classes used by proxy and API code.
+    let apiSandbox = sandbox(principals, { wantXrays: true, sameZoneAs: window });
+    apiSandbox.console = console;
+
+    // Create the sandbox and bind it to window in order for content scripts to
+    // have access to all standard globals (window, document, ...)
+    let content = sandbox(principals, {
+      sandboxPrototype: proto,
+      wantXrays: true,
+      wantGlobalProperties: wantGlobalProperties,
+      sameZoneAs: window,
+      metadata: { SDKContentScript: true }
+    });
+    model.sandbox = content;
+    
+    // We have to ensure that window.top and window.parent are the exact same
+    // object than window object, i.e. the sandbox global object. But not
+    // always, in case of iframes, top and parent are another window object.
+    let top = window.top === window ? content : content.top;
+    let parent = window.parent === window ? content : content.parent;
+    merge(content, {
+      // We need 'this === window === top' to be true in toplevel scope:
+      get window() content,
+      get top() top,
+      get parent() parent,
+      // 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!
+      get unsafeWindow() window.wrappedJSObject
+    });
+
+    // Load trusted code that will inject content script API.
+    // We need to expose JS objects defined in same principal in order to
+    // avoid having any kind of wrapper.
+    load(apiSandbox, CONTENT_WORKER_URL);
+
+    // prepare a clean `self.options`
+    let options = 'contentScriptOptions' in worker ?
+      JSON.stringify(worker.contentScriptOptions) :
+      undefined;
+
+    // Then call `inject` method and communicate with this script
+    // by trading two methods that allow to send events to the other side:
+    //   - `onEvent` called by content script
+    //   - `result.emitToContent` called by addon script
+    // Bug 758203: We have to explicitely define `__exposedProps__` in order
+    // to allow access to these chrome object attributes from this sandbox with
+    // content priviledges
+    // https://developer.mozilla.org/en/XPConnect_wrappers#Other_security_wrappers
+    let onEvent = onContentEvent.bind(null, this);
+    // `ContentWorker` is defined in CONTENT_WORKER_URL file
+    let chromeAPI = createChromeAPI();
+    let result = apiSandbox.ContentWorker.inject(content, chromeAPI, onEvent, options);
+
+    // Merge `emitToContent` and `hasListenerFor` into our private
+    // model of the WorkerSandbox so we can communicate with content
+    // script
+    merge(model, result);
+
+    // Handle messages send by this script:
+    setListeners(this);
+
+    // Inject `addon` global into target document if document is trusted,
+    // `addon` in document is equivalent to `self` in content script.
+    if (requiresAddonGlobal(worker)) {
+      Object.defineProperty(getUnsafeWindow(window), 'addon', {
+          value: content.self
+        }
+      );
+    }
+
+    // Inject our `console` into target document if worker doesn't have a tab
+    // (e.g Panel, PageWorker, Widget).
+    // `worker.tab` can't be used because bug 804935.
+    if (!getTabForContentWindow(window)) {
+      let win = getUnsafeWindow(window);
+
+      // export our chrome console to content window, using the same approach
+      // of `ConsoleAPI`:
+      // http://mxr.mozilla.org/mozilla-central/source/dom/base/ConsoleAPI.js#150
+      //
+      // and described here:
+      // https://developer.mozilla.org/en-US/docs/Components.utils.createObjectIn
+      let con = Cu.createObjectIn(win);
+
+      let genPropDesc = function genPropDesc(fun) {
+        return { enumerable: true, configurable: true, writable: true,
+          value: console[fun] };
+      }
+
+      const properties = {
+        log: genPropDesc('log'),
+        info: genPropDesc('info'),
+        warn: genPropDesc('warn'),
+        error: genPropDesc('error'),
+        debug: genPropDesc('debug'),
+        trace: genPropDesc('trace'),
+        dir: genPropDesc('dir'),
+        group: genPropDesc('group'),
+        groupCollapsed: genPropDesc('groupCollapsed'),
+        groupEnd: genPropDesc('groupEnd'),
+        time: genPropDesc('time'),
+        timeEnd: genPropDesc('timeEnd'),
+        profile: genPropDesc('profile'),
+        profileEnd: genPropDesc('profileEnd'),
+       __noSuchMethod__: { enumerable: true, configurable: true, writable: true,
+                            value: function() {} }
+      };
+
+      Object.defineProperties(con, properties);
+      Cu.makeObjectPropsNormal(con);
+
+      win.console = con;
+    };
+
+    // 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)
+      importScripts.apply(null, [this].concat(contentScriptFile));
+    if (contentScript) {
+      evaluateIn(
+        this,
+        Array.isArray(contentScript) ? contentScript.join(';\n') : contentScript
+      );
+    }
+  },
+  destroy: function destroy() {
+    this.emitSync('detach');
+    let model = modelFor(this);
+    model.sandbox = null
+    model.worker = null;
+  },
+
+});
+
+exports.WorkerSandbox = WorkerSandbox;
+
+/**
+ * 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.
+ */
+function importScripts (workerSandbox, ...urls) {
+  let { worker, sandbox } = modelFor(workerSandbox);
+  for (let i in urls) {
+    let contentScriptFile = urls[i];
+    try {
+      let uri = URL(contentScriptFile);
+      if (uri.scheme === 'resource')
+        load(sandbox, String(uri));
+      else
+        throw Error('Unsupported `contentScriptFile` url: ' + String(uri));
+    }
+    catch(e) {
+      emit(worker, 'error', e);
+    }
+  }
+}
+
+function setListeners (workerSandbox) {
+  let { worker } = modelFor(workerSandbox);
+  // console.xxx calls
+  workerSandbox.on('console', function consoleListener (kind, ...args) {
+    console[kind].apply(console, args);
+  });
+
+  // self.postMessage calls
+  workerSandbox.on('message', function postMessage(data) {
+    // destroyed?
+    if (worker)
+      emit(worker, 'message', data);
+  });
+
+  // self.port.emit calls
+  workerSandbox.on('event', function portEmit (...eventArgs) {
+    // If not destroyed, emit event information to worker
+    // `eventArgs` has the event name as first element,
+    // and remaining elements are additional arguments to pass
+    if (worker)
+      emit.apply(null, [worker.port].concat(eventArgs));
+  });
+
+  // unwrap, recreate and propagate async Errors thrown from content-script
+  workerSandbox.on('error', function onError({instanceOfError, value}) {
+    if (worker) {
+      let error = value;
+      if (instanceOfError) {
+        error = new Error(value.message, value.fileName, value.lineNumber);
+        error.stack = value.stack;
+        error.name = value.name;
+      }
+      emit(worker, 'error', error);
+    }
+  });
+}
+
+/**
+ * Evaluates code in the sandbox.
+ * @param {String} code
+ *    JavaScript source to evaluate.
+ * @param {String} [filename='javascript:' + code]
+ *    Name of the file
+ */
+function evaluateIn (workerSandbox, code, filename) {
+  let { worker, sandbox } = modelFor(workerSandbox);
+  try {
+    evaluate(sandbox, code, filename || 'javascript:' + code);
+  }
+  catch(e) {
+    emit(worker, 'error', e);
+  }
+}
+
+/**
+ * Method called by the worker sandbox when it needs to send a message
+ */
+function onContentEvent (workerSandbox, args) {
+  // As `emit`, we ensure having an asynchronous behavior
+  async(function () {
+    // We emit event to chrome/addon listeners
+    emit.apply(null, [workerSandbox].concat(JSON.parse(args)));
+  });
+}
+
+
+function modelFor (workerSandbox) {
+  return sandboxes.get(workerSandbox);
+}
+
+/**
+ * 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;
+}
+
+function getUnsafeWindow (win) {
+  return win.wrappedJSObject || win;
+}
+
+function emitToContent (workerSandbox, args) {
+  return modelFor(workerSandbox).emitToContent(args);
+}
+
+function createChromeAPI () {
+  return {
+    timers: {
+      setTimeout: timer.setTimeout,
+      setInterval: timer.setInterval,
+      clearTimeout: timer.clearTimeout,
+      clearInterval: timer.clearInterval,
+      __exposedProps__: {
+        setTimeout: 'r',
+        setInterval: 'r',
+        clearTimeout: 'r',
+        clearInterval: 'r'
+      },
+    },
+    sandbox: {
+      evaluate: evaluate,
+      __exposedProps__: {
+        evaluate: 'r'
+      }
+    },
+    __exposedProps__: {
+      timers: 'r',
+      sandbox: 'r'
+    }
+  };
+}

deleted file mode 100644
--- a/addon-sdk/source/lib/sdk/content/symbiont.js
+++ /dev/null
@@ -1,229 +0,0 @@
-/* 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 { Worker } = require('./worker');
-const { Loader } = require('./loader');
-const hiddenFrames = require('../frame/hidden-frame');
-const observers = require('../deprecated/observer-service');
-const unload = require('../system/unload');
-const { getDocShell } = require("../frame/utils");
-const { ignoreWindow } = require('../private-browsing/utils');
-
-// Everything coming from add-on's xpi considered an asset.
-const assetsURI = require('../self').data.url().replace(/data\/$/, "");
-
-/**
- * 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 ('contentScriptOptions' in options)
-      this.contentScriptOptions = options.contentScriptOptions;
-    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);
-        },
-        onUnload: function onUnload() {
-          // Bug 751211: Remove reference to _frame when hidden frame is
-          // automatically removed on unload, otherwise we are going to face
-          // "dead object" exception
-          self.destroy();
-        }
-      });
-      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;
-
-    if (getDocShell(frame)) {
-      this._reallyInitFrame(frame);
-    }
-    else {
-      if (this._waitForFrame) {
-        observers.remove('content-document-global-created', this._waitForFrame);
-      }
-      this._waitForFrame = this.__waitForFrame.bind(this, frame);
-      observers.add('content-document-global-created', this._waitForFrame);
-    }
-  },
-
-  __waitForFrame: function _waitForFrame(frame, win, topic) {
-    if (frame.contentWindow == win) {
-      observers.remove('content-document-global-created', this._waitForFrame);
-      delete this._waitForFrame;
-      this._reallyInitFrame(frame);
-    }
-  },
-
-  _reallyInitFrame: function _reallyInitFrame(frame) {
-    getDocShell(frame).allowJavascript = this.allow.script;
-    frame.setAttribute("src", this._contentURL);
-
-    // Inject `addon` object in document if we load a document from
-    // one of our addon folder and if no content script are defined. bug 612726
-    let isDataResource =
-      typeof this._contentURL == "string" &&
-      this._contentURL.indexOf(assetsURI) == 0;
-    let hasContentScript =
-      (Array.isArray(this.contentScript) ? this.contentScript.length > 0
-                                             : !!this.contentScript) ||
-      (Array.isArray(this.contentScriptFile) ? this.contentScriptFile.length > 0
-                                             : !!this.contentScriptFile);
-    // If we have to inject `addon` we have to do it before document
-    // script execution, so during `start`:
-    this._injectInDocument = isDataResource && !hasContentScript;
-    if (this._injectInDocument)
-      this.contentScriptWhen = "start";
-
-    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 (ignoreWindow(window)) {
-            return;
-          }
-
-          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._waitForFrame) {
-      observers.remove('content-document-global-created', this._waitForFrame);
-      delete this._waitForFrame;
-    }
-
-    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;

--- a/addon-sdk/source/lib/sdk/content/utils.js
+++ b/addon-sdk/source/lib/sdk/content/utils.js
@@ -1,41 +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/. */
-"use strict";
+'use strict';
 
 module.metadata = {
-  "stability": "unstable"
+  'stability': 'unstable'
 };
 
-let assetsURI = require("../self").data.url();
+let { merge } = require('../util/object');
+let assetsURI = require('../self').data.url();
 let isArray = Array.isArray;
+let method = require('method/core');
 
 function isAddonContent({ contentURL }) {
-  return typeof(contentURL) === "string" && contentURL.indexOf(assetsURI) === 0;
+  return typeof(contentURL) === 'string' && contentURL.indexOf(assetsURI) === 0;
 }
 exports.isAddonContent = isAddonContent;
 
 function hasContentScript({ contentScript, contentScriptFile }) {
   return (isArray(contentScript) ? contentScript.length > 0 :
          !!contentScript) ||
          (isArray(contentScriptFile) ? contentScriptFile.length > 0 :
          !!contentScriptFile);
 }
 exports.hasContentScript = hasContentScript;
 
 function requiresAddonGlobal(model) {
-  return isAddonContent(model) && !hasContentScript(model);
+  return model.injectInDocument || (isAddonContent(model) && !hasContentScript(model));
 }
 exports.requiresAddonGlobal = requiresAddonGlobal;
 
 function getAttachEventType(model) {
   if (!model) return null;
   let when = model.contentScriptWhen;
-  return requiresAddonGlobal(model) ? "document-element-inserted" :
-         when === "start" ? "document-element-inserted" :
-         when === "end" ? "load" :
-         when === "ready" ? "DOMContentLoaded" :
+  return requiresAddonGlobal(model) ? 'document-element-inserted' :
+         when === 'start' ? 'document-element-inserted' :
+         when === 'end' ? 'load' :
+         when === 'ready' ? 'DOMContentLoaded' :
          null;
 }
 exports.getAttachEventType = getAttachEventType;
 
+let attach = method('worker-attach');
+exports.attach = attach;
+
+let detach = method('worker-detach');
+exports.detach = detach;
+
+let destroy = method('worker-destroy');
+exports.destroy = destroy;
+
+function WorkerHost (workerFor) {
+  // Define worker properties that just proxy to underlying worker
+  return ['postMessage', 'port', 'url', 'tab'].reduce(function(proto, name) {
+    // Use descriptor properties instead so we can call
+    // the worker function in the context of the worker so we
+    // don't have to create new functions with `fn.bind(worker)`
+    let descriptorProp = {
+      value: function (...args) {
+        let worker = workerFor(this);
+        return worker[name].apply(worker, args);
+      }
+    };
+    
+    let accessorProp = {
+      get: function () { return workerFor(this)[name]; },
+      set: function (value) { workerFor(this)[name] = value; }
+    };
+
+    Object.defineProperty(proto, name, merge({
+      enumerable: true,
+      configurable: false,
+    }, isDescriptor(name) ? descriptorProp : accessorProp));
+    return proto;
+  }, {});
+  
+  function isDescriptor (prop) {
+    return ~['postMessage'].indexOf(prop);
+  }
+}
+exports.WorkerHost = WorkerHost;

--- a/addon-sdk/source/lib/sdk/content/worker.js
+++ b/addon-sdk/source/lib/sdk/content/worker.js
@@ -2,650 +2,281 @@
  * 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 { Trait } = require('../deprecated/traits');
-const { EventEmitter, EventEmitterTrait } = require('../deprecated/events');
+const { Class } = require('../core/heritage');
+const { EventTarget } = require('../event/target');
+const { on, off, emit, setListeners } = require('../event/core');
+const {
+  attach, detach, destroy
+} = require('./utils');
+const { method } = require('../lang/functional');
 const { Ci, Cu, Cc } = require('chrome');
-const timer = require('../timers');
-const { URL } = require('../url');
 const unload = require('../system/unload');
-const observers = require('../deprecated/observer-service');
-const { Cortex } = require('../deprecated/cortex');
-const { sandbox, evaluate, load } = require("../loader/sandbox");
-const { merge } = require('../util/object');
-const xulApp = require("../system/xul-app");
-const { getInnerId } = require("../window/utils")
-const USE_JS_PROXIES = !xulApp.versionInRange(xulApp.platformVersion,
-                                              "17.0a2", "*");
+const events = require('../system/events');
+const { getInnerId } = require("../window/utils");
+const { WorkerSandbox } = require('./sandbox');
 const { getTabForWindow } = require('../tabs/helpers');
-const { getTabForContentWindow } = require('../tabs/utils');
-
-/* Trick the linker in order to ensure shipping these files in the XPI.
-  require('./content-worker.js');
-  Then, retrieve URL of these files in the XPI:
-*/
-let prefix = module.uri.split('worker.js')[0];
-const CONTENT_WORKER_URL = prefix + 'content-worker.js';
 
-// Fetch additional list of domains to authorize access to for each content
-// script. It is stored in manifest `metadata` field which contains
-// package.json data. This list is originaly defined by authors in
-// `permissions` attribute of their package.json addon file.
-const permissions = require('@loader/options').metadata['permissions'] || {};
-const EXPANDED_PRINCIPALS = permissions['cross-domain-content'] || [];
+// A weak map of workers to hold private attributes that
+// should not be exposed
+const workers = new WeakMap();
 
-const JS_VERSION = '1.8';
+let modelFor = (worker) => workers.get(worker);
 
 const ERR_DESTROYED =
   "Couldn't find the worker to receive this message. " +
   "The script may not be initialized yet, or may already have been unloaded.";
 
 const ERR_FROZEN = "The page is currently hidden and can no longer be used " +
                    "until it is visible again.";
 
 
-const WorkerSandbox = EventEmitter.compose({
-
-  /**
-   * Emit a message to the worker content sandbox
-   */
-  emit: function emit() {
-    // First ensure having a regular array
-    // (otherwise, `arguments` would be mapped to an object by `stringify`)
-    let array = Array.slice(arguments);
-    // 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;
-    }
-    // Ensure having an asynchronous behavior
-    let self = this;
-    timer.setTimeout(function () {
-      self._emitToContent(JSON.stringify(array, replacer));
-    }, 0);
-  },
-
-  /**
-   * Synchronous version of `emit`.
-   * /!\ Should only be used when it is strictly mandatory /!\
-   *     Doesn't ensure passing only JSON values.
-   *     Mainly used by context-menu in order to avoid breaking it.
-   */
-  emitSync: function emitSync() {
-    let args = Array.slice(arguments);
-    return this._emitToContent(args);
-  },
-
-  /**
-   * Tells if content script has at least one listener registered for one event,
-   * through `self.on('xxx', ...)`.
-   * /!\ Shouldn't be used. Implemented to avoid breaking context-menu API.
-   */
-  hasListenerFor: function hasListenerFor(name) {
-    return this._hasListenerFor(name);
-  },
-
-  /**
-   * Method called by the worker sandbox when it needs to send a message
-   */
-  _onContentEvent: function onContentEvent(args) {
-    // As `emit`, we ensure having an asynchronous behavior
-    let self = this;
-    timer.setTimeout(function () {
-      // We emit event to chrome/addon listeners
-      self._emit.apply(self, JSON.parse(args));
-    }, 0);
-  },
-
-  /**
-   * Configures sandbox and loads content scripts into it.
-   * @param {Worker} worker
-   *    content worker
-   */
-  constructor: function WorkerSandbox(worker) {
-    this._addonWorker = worker;
-
-    // Ensure that `emit` has always the right `this`
-    this.emit = this.emit.bind(this);
-    this.emitSync = this.emitSync.bind(this);
-
-    // We receive a wrapped window, that may be an xraywrapper if it's content
-    let window = worker._window;
-    let proto = window;
-
-    // Eventually use expanded principal sandbox feature, if some are given.
-    //
-    // But prevent it when the Worker isn't used for a content script but for
-    // injecting `addon` object into a Panel, Widget, ... scope.
-    // That's because:
-    // 1/ It is useless to use multiple domains as the worker is only used
-    // to communicate with the addon,
-    // 2/ By using it it would prevent the document to have access to any JS
-    // value of the worker. As JS values coming from multiple domain principals
-    // can't be accessed by "mono-principals" (principal with only one domain).
-    // Even if this principal is for a domain that is specified in the multiple
-    // domain principal.
-    let principals  = window;
-    let wantGlobalProperties = []
-    if (EXPANDED_PRINCIPALS.length > 0 && !worker._injectInDocument) {
-      principals = EXPANDED_PRINCIPALS.concat(window);
-      // We have to replace XHR constructor of the content document
-      // with a custom cross origin one, automagically added by platform code:
-      delete proto.XMLHttpRequest;
-      wantGlobalProperties.push("XMLHttpRequest");
-    }
-
-    // Instantiate trusted code in another Sandbox in order to prevent content
-    // script from messing with standard classes used by proxy and API code.
-    let apiSandbox = sandbox(principals, { wantXrays: true, sameZoneAs: window });
-    apiSandbox.console = console;
-
-    // Create the sandbox and bind it to window in order for content scripts to
-    // have access to all standard globals (window, document, ...)
-    let content = this._sandbox = sandbox(principals, {
-      sandboxPrototype: proto,
-      wantXrays: true,
-      wantGlobalProperties: wantGlobalProperties,
-      sameZoneAs: window,
-      metadata: { SDKContentScript: true }
-    });
-    // We have to ensure that window.top and window.parent are the exact same
-    // object than window object, i.e. the sandbox global object. But not
-    // always, in case of iframes, top and parent are another window object.
-    let top = window.top === window ? content : content.top;
-    let parent = window.parent === window ? content : content.parent;
-    merge(content, {
-      // We need "this === window === top" to be true in toplevel scope:
-      get window() content,
-      get top() top,
-      get parent() parent,
-      // 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!
-      get unsafeWindow() window.wrappedJSObject
-    });
-
-    // Load trusted code that will inject content script API.
-    // We need to expose JS objects defined in same principal in order to
-    // avoid having any kind of wrapper.
-    load(apiSandbox, CONTENT_WORKER_URL);
-
-    // prepare a clean `self.options`
-    let options = 'contentScriptOptions' in worker ?
-      JSON.stringify( worker.contentScriptOptions ) :
-      undefined;
-
-    // Then call `inject` method and communicate with this script
-    // by trading two methods that allow to send events to the other side:
-    //   - `onEvent` called by content script
-    //   - `result.emitToContent` called by addon script
-    // Bug 758203: We have to explicitely define `__exposedProps__` in order
-    // to allow access to these chrome object attributes from this sandbox with
-    // content priviledges
-    // https://developer.mozilla.org/en/XPConnect_wrappers#Other_security_wrappers
-    let chromeAPI = {
-      timers: {
-        setTimeout: timer.setTimeout,
-        setInterval: timer.setInterval,
-        clearTimeout: timer.clearTimeout,
-        clearInterval: timer.clearInterval,
-        __exposedProps__: {
-          setTimeout: 'r',
-          setInterval: 'r',
-          clearTimeout: 'r',
-          clearInterval: 'r'
-        }
-      },
-      sandbox: {
-        evaluate: evaluate,
-        __exposedProps__: {
-          evaluate: 'r',
-        }
-      },
-      __exposedProps__: {
-        timers: 'r',
-        sandbox: 'r',
-      }
-    };
-    let onEvent = this._onContentEvent.bind(this);
-    // `ContentWorker` is defined in CONTENT_WORKER_URL file
-    let result = apiSandbox.ContentWorker.inject(content, chromeAPI, onEvent, options);
-    this._emitToContent = result.emitToContent;
-    this._hasListenerFor = result.hasListenerFor;
-
-    // Handle messages send by this script:
-    let self = this;
-    // console.xxx calls
-    this.on("console", function consoleListener(kind) {
-      console[kind].apply(console, Array.slice(arguments, 1));
-    });
-
-    // self.postMessage calls
-    this.on("message", function postMessage(data) {
-      // destroyed?
-      if (self._addonWorker)
-        self._addonWorker._emit('message', data);
-    });
-
-    // self.port.emit calls
-    this.on("event", function portEmit(name, args) {
-      // destroyed?
-      if (self._addonWorker)
-        self._addonWorker._onContentScriptEvent.apply(self._addonWorker, arguments);
-    });
-
-    // unwrap, recreate and propagate async Errors thrown from content-script
-    this.on("error", function onError({instanceOfError, value}) {
-      if (self._addonWorker) {
-        let error = value;
-        if (instanceOfError) {
-          error = new Error(value.message, value.fileName, value.lineNumber);
-          error.stack = value.stack;
-          error.name = value.name;
-        }
-        self._addonWorker._emit('error', error);
-      }
-    });
-
-    // Inject `addon` global into target document if document is trusted,
-    // `addon` in document is equivalent to `self` in content script.
-    if (worker._injectInDocument) {
-      let win = window.wrappedJSObject ? window.wrappedJSObject : window;
-      Object.defineProperty(win, "addon", {
-          value: content.self
-        }
-      );
-    }
-
-    // Inject our `console` into target document if worker doesn't have a tab
-    // (e.g Panel, PageWorker, Widget).
-    // `worker.tab` can't be used because bug 804935.
-    if (!getTabForContentWindow(window)) {
-      let win = window.wrappedJSObject ? window.wrappedJSObject : window;
-
-      // export our chrome console to content window, using the same approach
-      // of `ConsoleAPI`:
-      // http://mxr.mozilla.org/mozilla-central/source/dom/base/ConsoleAPI.js#150
-      //
-      // and described here:
-      // https://developer.mozilla.org/en-US/docs/Components.utils.createObjectIn
-      let con = Cu.createObjectIn(win);
-
-      let genPropDesc = function genPropDesc(fun) {
-        return { enumerable: true, configurable: true, writable: true,
-          value: console[fun] };
-      }
-
-      const properties = {
-        log: genPropDesc('log'),
-        info: genPropDesc('info'),
-        warn: genPropDesc('warn'),
-        error: genPropDesc('error'),
-        debug: genPropDesc('debug'),
-        trace: genPropDesc('trace'),
-        dir: genPropDesc('dir'),
-        group: genPropDesc('group'),
-        groupCollapsed: genPropDesc('groupCollapsed'),
-        groupEnd: genPropDesc('groupEnd'),
-        time: genPropDesc('time'),
-        timeEnd: genPropDesc('timeEnd'),
-        profile: genPropDesc('profile'),
-        profileEnd: genPropDesc('profileEnd'),
-       __noSuchMethod__: { enumerable: true, configurable: true, writable: true,
-                            value: function() {} }
-      };
-
-      Object.defineProperties(con, properties);
-      Cu.makeObjectPropsNormal(con);
-
-      win.console = con;
-    };
-
-    // 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
-      );
-    }
-  },
-  destroy: function destroy() {
-    this.emitSync("detach");
-    this._sandbox = null;
-    this._addonWorker = null;
-  },
-
-  /**
-   * 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) {
-    try {
-      evaluate(this._sandbox, code, filename || 'javascript:' + code);
-    }
-    catch(e) {
-      this._addonWorker._emit('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 uri = URL(contentScriptFile);
-        if (uri.scheme === 'resource')
-          load(this._sandbox, String(uri));
-        else
-          throw Error("Unsupported `contentScriptFile` url: " + String(uri));
-      }
-      catch(e) {
-        this._addonWorker._emit('error', e);
-      }
-    }
-  }
-});
-
 /**
  * Message-passing facility for communication between code running
  * in the content and add-on process.
  * @see https://addons.mozilla.org/en-US/developers/docs/sdk/latest/modules/sdk/content/worker.html
  */
-const Worker = EventEmitter.compose({
-  on: Trait.required,
-  _removeAllListeners: Trait.required,
+const Worker = Class({
+  implements: [EventTarget],
+  initialize: function WorkerConstructor (options) {
+    // Save model in weak map to not expose properties
+    let model = createModel();
+    workers.set(this, model);
+
+    options = options || {};
 
-  // List of messages fired before worker is initialized
-  get _earlyEvents() {
-    delete this._earlyEvents;
-    this._earlyEvents = [];
-    return this._earlyEvents;
+    if ('contentScriptFile' in options)
+      this.contentScriptFile = options.contentScriptFile;
+    if ('contentScriptOptions' in options)
+      this.contentScriptOptions = options.contentScriptOptions;
+    if ('contentScript' in options)
+      this.contentScript = options.contentScript;
+    if ('injectInDocument' in options)
+      this.injectInDocument = !!options.injectInDocument;
+
+    setListeners(this, options);
+
+    unload.ensure(this, "destroy");
+
+    // Ensure that worker.port is initialized for contentWorker to be able
+    // to send events during worker initialization.
+    this.port = createPort(this);
+
+    model.documentUnload = documentUnload.bind(this);
+    model.pageShow = pageShow.bind(this);
+    model.pageHide = pageHide.bind(this);
+
+    if ('window' in options)
+      attach(this, options.window);
   },
 
   /**
    * 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 (data) {
-    let args = ['message'].concat(Array.slice(arguments));
-    if (!this._inited) {
-      this._earlyEvents.push(args);
+  postMessage: function (...data) {
+    let model = modelFor(this);
+    let args = ['message'].concat(data);
+    if (!model.inited) {
+      model.earlyEvents.push(args);
       return;
     }
-    processMessage.apply(this, args);
-  },
-
-  /**
-   * 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
-    this._port = EventEmitterTrait.create({
-      emit: this._emitEventToContent.bind(this)
-    });
-
-    // 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 _emit, 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 () {
-    let args = ['event'].concat(Array.slice(arguments));
-    if (!this._inited) {
-      this._earlyEvents.push(args);
-      return;
-    }
-    processMessage.apply(this, args);
+    processMessage.apply(null, [this].concat(args));
   },
 
-  // Is worker connected to the content worker sandbox ?
-  _inited: false,
-
-  // Is worker being frozen? i.e related document is frozen in bfcache.
-  // Content script should not be reachable if frozen.
-  _frozen: true,
-
-  constructor: function Worker(options) {
-    options = options || {};
-
-    if ('contentScriptFile' in options)
-      this.contentScriptFile = options.contentScriptFile;
-    if ('contentScriptOptions' in options)
-      this.contentScriptOptions = options.contentScriptOptions;
-    if ('contentScript' in options)
-      this.contentScript = options.contentScript;
-
-    this._setListeners(options);
-
-    unload.ensure(this._public, "destroy");
-
-    // Ensure that worker._port is initialized for contentWorker to be able
-    // to send events during worker initialization.
-    this.port;
-
-    this._documentUnload = this._documentUnload.bind(this);
-    this._pageShow = this._pageShow.bind(this);
-    this._pageHide = this._pageHide.bind(this);
-
-    if ("window" in options) this._attach(options.window);
-  },
-
-  _setListeners: function(options) {
-    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);
+  get url () {
+    let model = modelFor(this);
+    // model.window will be null after detach
+    return model.window ? model.window.document.location.href : null;
   },
 
-  _attach: function(window) {
-    this._window = window;
-    // 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 = getInnerId(this._window);
-    observers.add("inner-window-destroyed", this._documentUnload);
-
-    // Listen to pagehide event in order to freeze the content script
-    // while the document is frozen in bfcache:
-    this._window.addEventListener("pageshow", this._pageShow, true);
-    this._window.addEventListener("pagehide", this._pageHide, true);
-
-    // will set this._contentWorker pointing to the private API:
-    this._contentWorker = WorkerSandbox(this);
-
-    // Mainly enable worker.port.emit to send event to the content worker
-    this._inited = true;
-    this._frozen = false;
-
-    // Process all events and messages that were fired before the
-    // worker was initialized.
-    this._earlyEvents.forEach((function (args) {
-      processMessage.apply(this, args);
-    }).bind(this));
+  get contentURL () {
+    let model = modelFor(this);
+    return model.window ? model.window.document.URL : null;
   },
 
-  _documentUnload: function _documentUnload(subject, topic, data) {
-    let innerWinID = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
-    if (innerWinID != this._windowID) return false;
-    this._workerCleanup();
-    return true;
-  },
-
-  _pageShow: function _pageShow() {
-    this._contentWorker.emitSync("pageshow");
-    this._emit("pageshow");
-    this._frozen = false;
-  },
-
-  _pageHide: function _pageHide() {
-    this._contentWorker.emitSync("pagehide");
-    this._emit("pagehide");
-    this._frozen = true;
-  },
-
-  get url() {
-    // this._window will be null after detach
-    return this._window ? this._window.document.location.href : null;
-  },
-
-  get tab() {
-    // this._window will be null after detach
-    if (this._window)
-      return getTabForWindow(this._window);
+  get tab () {
+    let model = modelFor(this);
+    // model.window will be null after detach
+    if (model.window)
+      return getTabForWindow(model.window);
     return null;
   },
 
-  /**
-   * Tells content worker to unload itself and
-   * removes all the references from itself.
-   */
-  destroy: function destroy() {
-    this._workerCleanup();
-    this._inited = true;
-    this._removeAllListeners();
+  // Implemented to provide some of the previous features of exposing sandbox
+  // so that Worker can be extended
+  getSandbox: function () {
+    return modelFor(this).contentWorker;
   },
 
-  /**
-   * 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.destroy();
-    this._contentWorker = null;
-    if (this._window) {
-      this._window.removeEventListener("pageshow", this._pageShow, true);
-      this._window.removeEventListener("pagehide", this._pageHide, true);
-    }
-    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.length = 0;
-      this._emit("detach");
-    }
-    this._inited = false;
-  },
+  toString: function () { return '[object Worker]'; },
+  attach: method(attach),
+  detach: method(detach),
+  destroy: method(destroy)
+});
+exports.Worker = Worker;
+
+attach.define(Worker, function (worker, window) {
+  let model = modelFor(worker);
+  model.window = window;
+  // 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
+  model.windowID = getInnerId(model.window);
+  events.on("inner-window-destroyed", model.documentUnload);
 
-  /**
-   * 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() {
-    this._port._emit.apply(this._port, arguments);
-  },
+  // Listen to pagehide event in order to freeze the content script
+  // while the document is frozen in bfcache:
+  model.window.addEventListener("pageshow", model.pageShow, true);
+  model.window.addEventListener("pagehide", model.pageHide, true);
+
+  // will set model.contentWorker pointing to the private API:
+  model.contentWorker = WorkerSandbox(worker, model.window);
 
-  /**
-   * Reference to the content side of the worker.
-   * @type {WorkerGlobalScope}
-   */
-  _contentWorker: null,
+  // Mainly enable worker.port.emit to send event to the content worker
+  model.inited = true;
+  model.frozen = false;
 
-  /**
-   * Reference to the window that is accessible from
-   * the content scripts.
-   * @type {Object}
-   */
-  _window: null,
+  // Fire off `attach` event
+  emit(worker, 'attach', window);
 
-  /**
-   * Flag to enable `addon` object injection in document. (bug 612726)
-   * @type {Boolean}
-   */
-  _injectInDocument: false
+  // Process all events and messages that were fired before the
+  // worker was initialized.
+  model.earlyEvents.forEach(args => processMessage.apply(null, [worker].concat(args)));
 });
 
 /**
- * Fired from postMessage and _emitEventToContent, or from the _earlyMessage
+ * Remove all internal references to the attached document
+ * Tells _port to unload itself and removes all the references from itself.
+ */
+detach.define(Worker, function (worker) {
+  let model = modelFor(worker);
+  // maybe unloaded before content side is created
+  if (model.contentWorker)
+    model.contentWorker.destroy();
+  model.contentWorker = null;
+  if (model.window) {
+    model.window.removeEventListener("pageshow", model.pageShow, true);
+    model.window.removeEventListener("pagehide", model.pageHide, true);
+  }
+  model.window = null;
+  // This method may be called multiple times,
+  // avoid dispatching `detach` event more than once
+  if (model.windowID) {
+    model.windowID = null;
+    events.off("inner-window-destroyed", model.documentUnload);
+    model.earlyEvents.length = 0;
+    emit(worker, 'detach');
+  }
+  model.inited = false;
+});
+
+/**
+ * Tells content worker to unload itself and
+ * removes all the references from itself.
+ */
+destroy.define(Worker, function (worker) {
+  detach(worker);
+  modelFor(worker).inited = true;
+  // Specifying no type or listener removes all listeners
+  // from target
+  off(worker);
+});
+
+/**
+ * Events fired by workers
+ */
+function documentUnload ({ subject, data }) {
+  let model = modelFor(this);
+  let innerWinID = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+  if (innerWinID != model.windowID) return false;
+  detach(this);
+  return true;
+}
+
+function pageShow () {
+  let model = modelFor(this);
+  model.contentWorker.emitSync('pageshow');
+  emit(this, 'pageshow');
+  model.frozen = false;
+}
+
+function pageHide () {
+  let model = modelFor(this);
+  model.contentWorker.emitSync('pagehide');
+  emit(this, 'pagehide');
+  model.frozen = true;
+}
+
+/**
+ * Fired from postMessage and emitEventToContent, or from the earlyMessage
  * queue when fired before the content is loaded. Sends arguments to
  * contentWorker if able
  */
 
-function processMessage () {
-  if (!this._contentWorker)
+function processMessage (worker, ...args) {
+  let model = modelFor(worker) || {};
+  if (!model.contentWorker)
     throw new Error(ERR_DESTROYED);
-  if (this._frozen)
+  if (model.frozen)
     throw new Error(ERR_FROZEN);
 
-  this._contentWorker.emit.apply(null, Array.slice(arguments));
+  model.contentWorker.emit.apply(null, args);
 }
 
-exports.Worker = Worker;
+function createModel () {
+  return {
+    // List of messages fired before worker is initialized
+    earlyEvents: [],
+    // Is worker connected to the content worker sandbox ?
+    inited: false,
+    // Is worker being frozen? i.e related document is frozen in bfcache.
+    // Content script should not be reachable if frozen.
+    frozen: true,
+    /**
+     * 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
+  };
+}
+
+function createPort (worker) {
+  let port = EventTarget();
+  port.emit = emitEventToContent.bind(null, worker);
+  return port;
+}
+
+/**
+ * Emit a custom event to the content script,
+ * i.e. emit this event on `self.port`
+ */
+function emitEventToContent (worker, ...eventArgs) {
+  let model = modelFor(worker);
+  let args = ['event'].concat(eventArgs);
+  if (!model.inited) {
+    model.earlyEvents.push(args);
+    return;
+  }
+  processMessage.apply(null, [worker].concat(args));
+}
+

--- a/addon-sdk/source/lib/sdk/context-menu.js
+++ b/addon-sdk/source/lib/sdk/context-menu.js
@@ -358,36 +358,38 @@ let menuRules = mix(labelledItemRules, {
         return item instanceof BaseItem;
       });
     },
     msg: "items must be an array, and each element in the array must be an " +
          "Item, Menu, or Separator."
   }
 });
 
-let ContextWorker = Worker.compose({
+let ContextWorker = Class({
+  implements: [ Worker ],
+
   //Returns true if any context listeners are defined in the worker's port.
   anyContextListeners: function anyContextListeners() {
-    return this._contentWorker.hasListenerFor("context");
+    return this.getSandbox().hasListenerFor("context");
   },
 
   // Calls the context workers context listeners and returns the first result
   // that is either a string or a value that evaluates to true. If all of the
   // listeners returned false then returns false. If there are no listeners
   // then returns null.
   getMatchedContext: function getCurrentContexts(popupNode) {
-    let results = this._contentWorker.emitSync("context", popupNode);
+    let results = this.getSandbox().emitSync("context", popupNode);
     return results.reduce(function(val, result) val || result, null);
   },
 
   // Emits a click event in the worker's port. popupNode is the node that was
   // context-clicked, and clickedItemData is the data of the item that was
   // clicked.
   fireClick: function fireClick(popupNode, clickedItemData) {
-    this._contentWorker.emitSync("click", popupNode, clickedItemData);
+    this.getSandbox().emitSync("click", popupNode, clickedItemData);
   }
 });
 
 // Returns true if any contexts match. If there are no contexts then a
 // PageContext is tested instead
 function hasMatchingContext(contexts, popupNode) {
   for (let context in contexts) {
     if (!context.isCurrent(popupNode))

--- a/addon-sdk/source/lib/sdk/deprecated/api-utils.js
+++ b/addon-sdk/source/lib/sdk/deprecated/api-utils.js
@@ -23,39 +23,16 @@ const VALID_TYPES = [
   "object",
   "string",
   "undefined",
 ];
 
 const { isArray } = Array;
 
 /**
- * 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

deleted file mode 100644
--- a/addon-sdk/source/lib/sdk/deprecated/app-strings.js
+++ /dev/null
@@ -1,67 +0,0 @@
-/* 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": "deprecated"
-};
-
-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];
-      }
-    }
-  );
-});

--- a/addon-sdk/source/lib/sdk/deprecated/memory.js
+++ b/addon-sdk/source/lib/sdk/deprecated/memory.js
@@ -1,53 +1,57 @@
 /* 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": "deprecated"
 };
 
-const {Cc,Ci,Cu,components} = require("chrome");
-var trackedObjects = {};
+const { Cc, Ci, Cu, components } = require("chrome");
+const { when: unload } = require("../system/unload")
 
-var Compacter = {
-  INTERVAL: 5000,
-  notify: function(timer) {
+var trackedObjects = {};
+const Compacter = {
+  notify: function() {
     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();
+      let oldBin = trackedObjects[name];
+      let newBin = [];
+      let strongRefs = [];
+
+      for (let i = 0, l = oldBin.length; i < l; i++) {
+        let 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,
+                       5000,
                        Ci.nsITimer.TYPE_REPEATING_SLACK);
 
-var track = exports.track = function track(object, bin, stackFrameNumber) {
+function track(object, bin, stackFrameNumber) {
   var frame = components.stack.caller;
   var weakref = Cu.getWeakReference(object);
+
   if (!bin && 'constructor' in object)
     bin = object.constructor.name;
   if (bin == "Object")
     bin = frame.name;
   if (!bin)
     bin = "generic";
   if (!(bin in trackedObjects))
     trackedObjects[bin] = [];
@@ -56,63 +60,70 @@ var track = exports.track = function tra
     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});
-};
+}
+exports.track = track;
 
 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]);
+function getObjects(bin) {
+  var results = [];
+
+  function getLiveObjectsInBin(bin) {
+    for (let i = 0, l = bin.length; i < l; i++) {
+      let object = bin[i].weakref.get();
+
+      if (object) {
+        results.push(bin[i]);
+      }
     }
   }
 
-  var results = [];
   if (bin) {
     if (bin in trackedObjects)
-      getLiveObjectsInBin(trackedObjects[bin], results);
-  } else
+      getLiveObjectsInBin(trackedObjects[bin]);
+  }
+  else {
     for (let name in trackedObjects)
-      getLiveObjectsInBin(trackedObjects[name], results);
+      getLiveObjectsInBin(trackedObjects[name]);
+  }
+
   return results;
-};
+}
+exports.getObjects = getObjects;
 
-var gc = exports.gc = function 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"]
+  var test_utils = Cc["@mozilla.org/appshell/appShellService;1"]
                .getService(Ci.nsIAppShellService)
-               .hiddenDOMWindow;
-  var test_utils = window.QueryInterface(Ci.nsIInterfaceRequestor)
-                   .getInterface(Ci.nsIDOMWindowUtils);
+               .hiddenDOMWindow
+               .QueryInterface(Ci.nsIInterfaceRequestor)
+               .getInterface(Ci.nsIDOMWindowUtils);
   test_utils.garbageCollect();
+  // Clean metadata for dead objects
   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();
 };
+exports.gc = gc;
 
-require("../system/unload").when(
-  function() {
-    trackedObjects = {};
-    if (timer) {
-      timer.cancel();
-      timer = null;
-    }
-  });
+unload(_ => {
+  trackedObjects = {};
+  if (timer) {
+    timer.cancel();
+    timer = null;
+  }
+});

deleted file mode 100644
--- a/addon-sdk/source/lib/sdk/deprecated/observer-service.js
+++ /dev/null
@@ -1,134 +0,0 @@
-/* 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": "deprecated"
-};
-
-const { Cc, Ci } = require("chrome");
-const { when: unload } = require("../system/unload");
-const { ns } = require("../core/namespace");
-const { on, off, emit, once } = require("../system/events");
-const { id } = require("../self");
-
-const subscribers = ns();
-const 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.
-   */
-  APPLICATION_READY: id + "_APPLICATION_READY"
-};
-
-function Listener(callback, target) {
-  return function listener({ subject, data }) {
-    callback.call(target || callback, subject, data);
-  }
-}
-
-/**
- * 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   target  {Object}  [optional]
- *          the object to use as |this| when calling a Function callback
- *
- * @returns the observer
- */
-function add(topic, callback, target) {
-  let listeners = subscribers(callback);
-  if (!(topic in listeners)) {
-    let listener = Listener(callback, target);
-    listeners[topic] = listener;
-
-    // Cache callback unless it's already cached.
-    if (!~cache.indexOf(callback))
-      cache.push(callback);
-
-    on(topic, listener);
-  }
-};
-exports.add = add;
-
-/**
- * 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   target  {Object}  [optional]
- *          the object being used as |this| when calling a Function callback
- */
-function remove(topic, callback, target) {
-  let listeners = subscribers(callback);
-  if (topic in listeners) {
-    let listener = listeners[topic];
-    delete listeners[topic];
-
-    // If no more observers are registered and callback is still in cache
-    // then remove it.
-    let index = cache.indexOf(callback);
-    if (~index && !Object.keys(listeners).length)
-      cache.splice(index, 1)
-
-    off(topic, listener);
-  }
-};
-exports.remove = remove;
-
-/**
- * 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 })
- */
-function notify(topic, subject, data) {
-  emit(topic, {
-    subject: subject === undefined ? null : subject,
-    data: data === undefined ? null : data
-  });
-}
-exports.notify = notify;
-
-unload(function() {
-  // Make a copy of cache first, since cache will be changing as we
-  // iterate through it.
-  cache.slice().forEach(function(callback) {
-    Object.keys(subscribers(callback)).forEach(function(topic) {
-      remove(topic, callback);
-    });
-  });
-})

new file mode 100644
--- /dev/null
+++ b/addon-sdk/source/lib/sdk/deprecated/symbiont.js
@@ -0,0 +1,229 @@
+/* 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": "deprecated"
+};
+
+const { Worker } = require('./traits-worker');
+const { Loader } = require('../content/loader');
+const hiddenFrames = require('../frame/hidden-frame');
+const { on, off } = require('../system/events');
+const unload = require('../system/unload');
+const { getDocShell } = require("../frame/utils");
+const { ignoreWindow } = require('../private-browsing/utils');
+
+// Everything coming from add-on's xpi considered an asset.
+const assetsURI = require('../self').data.url().replace(/data\/$/, "");
+
+/**
+ * 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 ('contentScriptOptions' in options)
+      this.contentScriptOptions = options.contentScriptOptions;
+    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);
+        },
+        onUnload: function onUnload() {
+          // Bug 751211: Remove reference to _frame when hidden frame is
+          // automatically removed on unload, otherwise we are going to face
+          // "dead object" exception
+          self.destroy();
+        }
+      });
+      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;
+
+    if (getDocShell(frame)) {
+      this._reallyInitFrame(frame);
+    }
+    else {
+      if (this._waitForFrame) {
+        off('content-document-global-created', this._waitForFrame);
+      }
+      this._waitForFrame = this.__waitForFrame.bind(this, frame);
+      on('content-document-global-created', this._waitForFrame);
+    }
+  },
+
+  __waitForFrame: function _waitForFrame(frame, { subject: win }) {
+    if (frame.contentWindow == win) {
+      off('content-document-global-created', this._waitForFrame);
+      delete this._waitForFrame;
+      this._reallyInitFrame(frame);
+    }
+  },
+
+  _reallyInitFrame: function _reallyInitFrame(frame) {
+    getDocShell(frame).allowJavascript = this.allow.script;
+    frame.setAttribute("src", this._contentURL);
+
+    // Inject `addon` object in document if we load a document from
+    // one of our addon folder and if no content script are defined. bug 612726
+    let isDataResource =
+      typeof this._contentURL == "string" &&
+      this._contentURL.indexOf(assetsURI) == 0;
+    let hasContentScript =
+      (Array.isArray(this.contentScript) ? this.contentScript.length > 0
+                                             : !!this.contentScript) ||
+      (Array.isArray(this.contentScriptFile) ? this.contentScriptFile.length > 0
+                                             : !!this.contentScriptFile);
+    // If we have to inject `addon` we have to do it before document
+    // script execution, so during `start`:
+    this._injectInDocument = isDataResource && !hasContentScript;
+    if (this._injectInDocument)
+      this.contentScriptWhen = "start";
+
+    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';
+      on('document-element-inserted',
+        this._loadListener = function onStart({ subject: doc }) {
+          let window = doc.defaultView;
+
+          if (ignoreWindow(window)) {
+            return;
+          }
+
+          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._waitForFrame) {
+      off('content-document-global-created', this._waitForFrame);
+      delete this._waitForFrame;
+    }
+
+    if (!this._loadListener)
+      return;
+    if (this._loadEvent == "start") {
+      off('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;

new file mode 100644
--- /dev/null
+++ b/addon-sdk/source/lib/sdk/deprecated/traits-worker.js
@@ -0,0 +1,660 @@
+/* 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/. */
+
+/**
+ *
+ * `deprecated/traits-worker` was previously `content/worker` and kept
+ * only due to `deprecated/symbiont` using it, which is necessary for
+ * `widget`, until that reaches deprecation EOL.
+ *
+ */
+
+"use strict";
+
+module.metadata = {
+  "stability": "deprecated"
+};
+
+const { Trait } = require('./traits');
+const { EventEmitter, EventEmitterTrait } = require('./events');
+const { Ci, Cu, Cc } = require('chrome');
+const timer = require('../timers');
+const { URL } = require('../url');
+const unload = require('../system/unload');
+const observers = require('../system/events');
+const { Cortex } = require('./cortex');
+const { sandbox, evaluate, load } = require("../loader/sandbox");
+const { merge } = require('../util/object');
+const xulApp = require("../system/xul-app");
+const { getInnerId } = require("../window/utils")
+const USE_JS_PROXIES = !xulApp.versionInRange(xulApp.platformVersion,
+                                              "17.0a2", "*");
+const { getTabForWindow } = require('../tabs/helpers');
+const { getTabForContentWindow } = require('../tabs/utils');
+
+/* Trick the linker in order to ensure shipping these files in the XPI.
+  require('../content/content-worker.js');
+  Then, retrieve URL of these files in the XPI:
+*/
+let prefix = module.uri.split('deprecated/traits-worker.js')[0];
+const CONTENT_WORKER_URL = prefix + 'content/content-worker.js';
+
+// Fetch additional list of domains to authorize access to for each content
+// script. It is stored in manifest `metadata` field which contains
+// package.json data. This list is originaly defined by authors in
+// `permissions` attribute of their package.json addon file.
+const permissions = require('@loader/options').metadata['permissions'] || {};
+const EXPANDED_PRINCIPALS = permissions['cross-domain-content'] || [];
+
+const JS_VERSION = '1.8';
+
+const ERR_DESTROYED =
+  "Couldn't find the worker to receive this message. " +
+  "The script may not be initialized yet, or may already have been unloaded.";
+
+const ERR_FROZEN = "The page is currently hidden and can no longer be used " +
+                   "until it is visible again.";
+
+
+const WorkerSandbox = EventEmitter.compose({
+
+  /**
+   * Emit a message to the worker content sandbox
+   */
+  emit: function emit() {
+    // First ensure having a regular array
+    // (otherwise, `arguments` would be mapped to an object by `stringify`)
+    let array = Array.slice(arguments);
+    // 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;
+    }
+    // Ensure having an asynchronous behavior
+    let self = this;
+    timer.setTimeout(function () {
+      self._emitToContent(JSON.stringify(array, replacer));
+    }, 0);
+  },
+
+  /**
+   * Synchronous version of `emit`.
+   * /!\ Should only be used when it is strictly mandatory /!\
+   *     Doesn't ensure passing only JSON values.
+   *     Mainly used by context-menu in order to avoid breaking it.
+   */
+  emitSync: function emitSync() {
+    let args = Array.slice(arguments);
+    return this._emitToContent(args);
+  },
+
+  /**
+   * Tells if content script has at least one listener registered for one event,
+   * through `self.on('xxx', ...)`.
+   * /!\ Shouldn't be used. Implemented to avoid breaking context-menu API.
+   */
+  hasListenerFor: function hasListenerFor(name) {
+    return this._hasListenerFor(name);
+  },
+
+  /**
+   * Method called by the worker sandbox when it needs to send a message
+   */
+  _onContentEvent: function onContentEvent(args) {
+    // As `emit`, we ensure having an asynchronous behavior
+    let self = this;
+    timer.setTimeout(function () {
+      // We emit event to chrome/addon listeners
+      self._emit.apply(self, JSON.parse(args));
+    }, 0);
+  },
+
+  /**
+   * Configures sandbox and loads content scripts into it.
+   * @param {Worker} worker
+   *    content worker
+   */
+  constructor: function WorkerSandbox(worker) {
+    this._addonWorker = worker;
+
+    // Ensure that `emit` has always the right `this`
+    this.emit = this.emit.bind(this);
+    this.emitSync = this.emitSync.bind(this);
+
+    // We receive a wrapped window, that may be an xraywrapper if it's content
+    let window = worker._window;
+    let proto = window;
+
+    // Eventually use expanded principal sandbox feature, if some are given.
+    //
+    // But prevent it when the Worker isn't used for a content script but for
+    // injecting `addon` object into a Panel, Widget, ... scope.
+    // That's because:
+    // 1/ It is useless to use multiple domains as the worker is only used
+    // to communicate with the addon,
+    // 2/ By using it it would prevent the document to have access to any JS
+    // value of the worker. As JS values coming from multiple domain principals
+    // can't be accessed by "mono-principals" (principal with only one domain).
+    // Even if this principal is for a domain that is specified in the multiple
+    // domain principal.
+    let principals  = window;
+    let wantGlobalProperties = []
+    if (EXPANDED_PRINCIPALS.length > 0 && !worker._injectInDocument) {
+      principals = EXPANDED_PRINCIPALS.concat(window);
+      // We have to replace XHR constructor of the content document
+      // with a custom cross origin one, automagically added by platform code:
+      delete proto.XMLHttpRequest;
+      wantGlobalProperties.push("XMLHttpRequest");
+    }
+
+    // Instantiate trusted code in another Sandbox in order to prevent content
+    // script from messing with standard classes used by proxy and API code.
+    let apiSandbox = sandbox(principals, { wantXrays: true, sameZoneAs: window });
+    apiSandbox.console = console;
+
+    // Create the sandbox and bind it to window in order for content scripts to
+    // have access to all standard globals (window, document, ...)
+    let content = this._sandbox = sandbox(principals, {
+      sandboxPrototype: proto,
+      wantXrays: true,
+      wantGlobalProperties: wantGlobalProperties,
+      sameZoneAs: window,
+      metadata: { SDKContentScript: true }
+    });
+    // We have to ensure that window.top and window.parent are the exact same
+    // object than window object, i.e. the sandbox global object. But not
+    // always, in case of iframes, top and parent are another window object.
+    let top = window.top === window ? content : content.top;
+    let parent = window.parent === window ? content : content.parent;
+    merge(content, {
+      // We need "this === window === top" to be true in toplevel scope:
+      get window() content,
+      get top() top,
+      get parent() parent,
+      // 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!
+      get unsafeWindow() window.wrappedJSObject
+    });
+
+    // Load trusted code that will inject content script API.
+    // We need to expose JS objects defined in same principal in order to
+    // avoid having any kind of wrapper.
+    load(apiSandbox, CONTENT_WORKER_URL);
+
+    // prepare a clean `self.options`
+    let options = 'contentScriptOptions' in worker ?
+      JSON.stringify( worker.contentScriptOptions ) :
+      undefined;
+
+    // Then call `inject` method and communicate with this script
+    // by trading two methods that allow to send events to the other side:
+    //   - `onEvent` called by content script
+    //   - `result.emitToContent` called by addon script
+    // Bug 758203: We have to explicitely define `__exposedProps__` in order
+    // to allow access to these chrome object attributes from this sandbox with
+    // content priviledges
+    // https://developer.mozilla.org/en/XPConnect_wrappers#Other_security_wrappers
+    let chromeAPI = {
+      timers: {
+        setTimeout: timer.setTimeout,
+        setInterval: timer.setInterval,
+        clearTimeout: timer.clearTimeout,
+        clearInterval: timer.clearInterval,
+        __exposedProps__: {
+          setTimeout: 'r',
+          setInterval: 'r',
+          clearTimeout: 'r',
+          clearInterval: 'r'
+        }
+      },
+      sandbox: {
+        evaluate: evaluate,
+        __exposedProps__: {
+          evaluate: 'r',
+        }
+      },
+      __exposedProps__: {
+        timers: 'r',
+        sandbox: 'r',
+      }
+    };
+    let onEvent = this._onContentEvent.bind(this);
+    // `ContentWorker` is defined in CONTENT_WORKER_URL file
+    let result = apiSandbox.ContentWorker.inject(content, chromeAPI, onEvent, options);
+    this._emitToContent = result.emitToContent;
+    this._hasListenerFor = result.hasListenerFor;
+
+    // Handle messages send by this script:
+    let self = this;
+    // console.xxx calls
+    this.on("console", function consoleListener(kind) {
+      console[kind].apply(console, Array.slice(arguments, 1));
+    });
+
+    // self.postMessage calls
+    this.on("message", function postMessage(data) {
+      // destroyed?
+      if (self._addonWorker)
+        self._addonWorker._emit('message', data);
+    });
+
+    // self.port.emit calls
+    this.on("event", function portEmit(name, args) {
+      // destroyed?
+      if (self._addonWorker)
+        self._addonWorker._onContentScriptEvent.apply(self._addonWorker, arguments);
+    });
+
+    // unwrap, recreate and propagate async Errors thrown from content-script
+    this.on("error", function onError({instanceOfError, value}) {
+      if (self._addonWorker) {
+        let error = value;
+        if (instanceOfError) {
+          error = new Error(value.message, value.fileName, value.lineNumber);
+          error.stack = value.stack;
+          error.name = value.name;
+        }
+        self._addonWorker._emit('error', error);
+      }
+    });
+
+    // Inject `addon` global into target document if document is trusted,
+    // `addon` in document is equivalent to `self` in content script.
+    if (worker._injectInDocument) {
+      let win = window.wrappedJSObject ? window.wrappedJSObject : window;
+      Object.defineProperty(win, "addon", {
+          value: content.self
+        }
+      );
+    }
+
+    // Inject our `console` into target document if worker doesn't have a tab
+    // (e.g Panel, PageWorker, Widget).
+    // `worker.tab` can't be used because bug 804935.
+    if (!getTabForContentWindow(window)) {
+      let win = window.wrappedJSObject ? window.wrappedJSObject : window;
+
+      // export our chrome console to content window, using the same approach
+      // of `ConsoleAPI`:
+      // http://mxr.mozilla.org/mozilla-central/source/dom/base/ConsoleAPI.js#150
+      //
+      // and described here:
+      // https://developer.mozilla.org/en-US/docs/Components.utils.createObjectIn
+      let con = Cu.createObjectIn(win);
+
+      let genPropDesc = function genPropDesc(fun) {
+        return { enumerable: true, configurable: true, writable: true,
+          value: console[fun] };
+      }
+
+      const properties = {
+        log: genPropDesc('log'),
+        info: genPropDesc('info'),
+        warn: genPropDesc('warn'),
+        error: genPropDesc('error'),
+        debug: genPropDesc('debug'),
+        trace: genPropDesc('trace'),
+        dir: genPropDesc('dir'),
+        group: genPropDesc('group'),
+        groupCollapsed: genPropDesc('groupCollapsed'),
+        groupEnd: genPropDesc('groupEnd'),
+        time: genPropDesc('time'),
+        timeEnd: genPropDesc('timeEnd'),
+        profile: genPropDesc('profile'),
+        profileEnd: genPropDesc('profileEnd'),
+       __noSuchMethod__: { enumerable: true, configurable: true, writable: true,
+                            value: function() {} }
+      };
+
+      Object.defineProperties(con, properties);
+      Cu.makeObjectPropsNormal(con);
+
+      win.console = con;
+    };
+
+    // 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
+      );
+    }
+  },
+  destroy: function destroy() {
+    this.emitSync("detach");
+    this._sandbox = null;
+    this._addonWorker = null;
+  },
+
+  /**
+   * 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) {
+    try {
+      evaluate(this._sandbox, code, filename || 'javascript:' + code);
+    }
+    catch(e) {
+      this._addonWorker._emit('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 uri = URL(contentScriptFile);
+        if (uri.scheme === 'resource')
+          load(this._sandbox, String(uri));
+        else
+          throw Error("Unsupported `contentScriptFile` url: " + String(uri));
+      }
+      catch(e) {
+        this._addonWorker._emit('error', e);
+      }
+    }
+  }
+});
+
+/**
+ * Message-passing facility for communication between code running
+ * in the content and add-on process.
+ * @see https://addons.mozilla.org/en-US/developers/docs/sdk/latest/modules/sdk/content/worker.html
+ */
+const Worker = EventEmitter.compose({
+  on: Trait.required,
+  _removeAllListeners: Trait.required,
+
+  // List of messages fired before worker is initialized
+  get _earlyEvents() {
+    delete this._earlyEvents;
+    this._earlyEvents = [];
+    return this._earlyEvents;
+  },
+
+  /**
+   * 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 (data) {
+    let args = ['message'].concat(Array.slice(arguments));
+    if (!this._inited) {
+      this._earlyEvents.push(args);
+      return;
+    }
+    processMessage.apply(this, args);
+  },
+
+  /**
+   * 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
+    this._port = EventEmitterTrait.create({
+      emit: this._emitEventToContent.bind(this)
+    });
+
+    // 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 _emit, 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 () {
+    let args = ['event'].concat(Array.slice(arguments));
+    if (!this._inited) {
+      this._earlyEvents.push(args);
+      return;
+    }
+    processMessage.apply(this, args);
+  },
+
+  // Is worker connected to the content worker sandbox ?
+  _inited: false,
+
+  // Is worker being frozen? i.e related document is frozen in bfcache.
+  // Content script should not be reachable if frozen.
+  _frozen: true,
+
+  constructor: function Worker(options) {
+    options = options || {};
+
+    if ('contentScriptFile' in options)
+      this.contentScriptFile = options.contentScriptFile;
+    if ('contentScriptOptions' in options)
+      this.contentScriptOptions = options.contentScriptOptions;
+    if ('contentScript' in options)
+      this.contentScript = options.contentScript;
+
+    this._setListeners(options);
+
+    unload.ensure(this._public, "destroy");
+
+    // Ensure that worker._port is initialized for contentWorker to be able
+    // to send events during worker initialization.
+    this.port;
+
+    this._documentUnload = this._documentUnload.bind(this);
+    this._pageShow = this._pageShow.bind(this);
+    this._pageHide = this._pageHide.bind(this);
+
+    if ("window" in options) this._attach(options.window);
+  },
+
+  _setListeners: function(options) {
+    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);
+  },
+
+  _attach: function(window) {
+    this._window = window;
+    // 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 = getInnerId(this._window);
+    observers.on("inner-window-destroyed", this._documentUnload);
+
+    // Listen to pagehide event in order to freeze the content script
+    // while the document is frozen in bfcache:
+    this._window.addEventListener("pageshow", this._pageShow, true);
+    this._window.addEventListener("pagehide", this._pageHide, true);
+
+    // will set this._contentWorker pointing to the private API:
+    this._contentWorker = WorkerSandbox(this);
+
+    // Mainly enable worker.port.emit to send event to the content worker
+    this._inited = true;
+    this._frozen = false;
+
+    // Process all events and messages that were fired before the
+    // worker was initialized.
+    this._earlyEvents.forEach((function (args) {
+      processMessage.apply(this, args);
+    }).bind(this));
+  },
+
+  _documentUnload: function _documentUnload({ subject, data }) {
+    let innerWinID = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+    if (innerWinID != this._windowID) return false;
+    this._workerCleanup();
+    return true;
+  },
+
+  _pageShow: function _pageShow() {
+    this._contentWorker.emitSync("pageshow");
+    this._emit("pageshow");
+    this._frozen = false;
+  },
+
+  _pageHide: function _pageHide() {
+    this._contentWorker.emitSync("pagehide");
+    this._emit("pagehide");
+    this._frozen = true;
+  },
+
+  get url() {
+    // this._window will be null after detach
+    return this._window ? this._window.document.location.href : null;
+  },
+
+  get tab() {
+    // this._window will be null after detach
+    if (this._window)
+      return getTabForWindow(this._window);
+    return null;
+  },
+
+  /**
+   * Tells content worker to unload itself and
+   * removes all the references from itself.
+   */
+  destroy: function destroy() {
+    this._workerCleanup();
+    this._inited = true;
+    this._removeAllListeners();
+  },
+
+  /**
+   * 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.destroy();
+    this._contentWorker = null;
+    if (this._window) {
+      this._window.removeEventListener("pageshow", this._pageShow, true);
+      this._window.removeEventListener("pagehide", this._pageHide, true);
+    }
+    this._window = null;
+    // This method may be called multiple times,
+    // avoid dispatching `detach` event more than once
+    if (this._windowID) {
+      this._windowID = null;
+      observers.off("inner-window-destroyed", this._documentUnload);
+      this._earlyEvents.length = 0;
+      this._emit("detach");
+    }
+    this._inited = false;
+  },
+
+  /**
+   * 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() {
+    this._port._emit.apply(this._port, 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,
+
+  /**
+   * Flag to enable `addon` object injection in document. (bug 612726)
+   * @type {Boolean}
+   */
+  _injectInDocument: false
+});
+
+/**
+ * Fired from postMessage and _emitEventToContent, or from the _earlyMessage
+ * queue when fired before the content is loaded. Sends arguments to
+ * contentWorker if able
+ */
+
+function processMessage () {
+  if (!this._contentWorker)
+    throw new Error(ERR_DESTROYED);
+  if (this._frozen)
+    throw new Error(ERR_FROZEN);
+
+  this._contentWorker.emit.apply(null, Array.slice(arguments));
+}
+
+exports.Worker = Worker;

--- a/addon-sdk/source/lib/sdk/event/core.js
+++ b/addon-sdk/source/lib/sdk/event/core.js
@@ -11,16 +11,17 @@ module.metadata = {
 const UNCAUGHT_ERROR = 'An error event was emitted for which there was no listener.';
 const BAD_LISTENER = 'The event listener must be a function.';
 
 const { ns } = require('../core/namespace');
 
 const event = ns();
 
 const EVENT_TYPE_PATTERN = /^on([A-Z]\w+$)/;
+exports.EVENT_TYPE_PATTERN = EVENT_TYPE_PATTERN;
 
 // Utility function to access given event `target` object's event listeners for
 // the specific event `type`. If listeners for this type does not exists they
 // will be created.
 const observers = function observers(target, type) {
   if (!target) throw TypeError("Event target must be an object");
   let listeners = event(target);
   return type in listeners ? listeners[type] : listeners[type] = [];
@@ -156,15 +157,16 @@ exports.count = count;
  *    The type of event.
  * @param {Object} listeners
  *    Dictionary of listeners.
  */
 function setListeners(target, listeners) {
   Object.keys(listeners || {}).forEach(key => {
     let match = EVENT_TYPE_PATTERN.exec(key);
     let type = match && match[1].toLowerCase();
-    let listener = listeners[key];
+    if (!type) return;
 
-    if (type && typeof(listener) === 'function')
+    let listener = listeners[key];
+    if (typeof(listener) === 'function')
       on(target, type, listener);
   });
 }
 exports.setListeners = setListeners;

--- a/addon-sdk/source/lib/sdk/event/utils.js
+++ b/addon-sdk/source/lib/sdk/event/utils.js
@@ -2,17 +2,17 @@
  * 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 { emit, on, once, off } = require("./core");
+let { emit, on, once, off, EVENT_TYPE_PATTERN } = require("./core");
 
 // This module provides set of high order function for working with event
 // streams (streams in a NodeJS style that dispatch data, end and error
 // events).
 
 // Function takes a `target` object and returns set of implicit references
 // (non property references) it keeps. This basically allows defining
 // references between objects without storing the explicitly. See transform for
@@ -250,8 +250,26 @@ Reactor.prototype.onNext = function(pres
 Reactor.prototype.run = function(input) {
   on(input, "data", message => this.onNext(message, input.value));
   on(input, "end", () => this.onEnd(input.value));
   start(input);
   this.value = input.value;
   this.onStart(input.value);
 };
 exports.Reactor = Reactor;
+
+/**
+ * Takes an object used as options with potential keys like 'onMessage',
+ * used to be called `require('sdk/event/core').setListeners` on.
+ * This strips all keys that would trigger a listener to be set.
+ * 
+ * @params {Object} object
+ * @return {Object}
+ */
+
+function stripListeners (object) {
+  return Object.keys(object).reduce((agg, key) => {
+    if (!EVENT_TYPE_PATTERN.test(key))
+      agg[key] = object[key];
+    return agg;
+  }, {});
+}
+exports.stripListeners = stripListeners;

--- a/addon-sdk/source/lib/sdk/l10n/prefs.js
+++ b/addon-sdk/source/lib/sdk/l10n/prefs.js
@@ -1,21 +1,20 @@
 /* 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";
 
-const observers = require("../deprecated/observer-service");
+const { on } = require("../system/events");
 const core = require("./core");
 const { id: jetpackId} = require('../self');
 
 const OPTIONS_DISPLAYED = "addon-options-displayed";
 
-function onOptionsDisplayed(document, addonId) {
+function onOptionsDisplayed({ subjec: document, data: addonId }) {
   if (addonId !== jetpackId)
     return;
   let query = 'setting[data-jetpack-id="' + jetpackId + '"][pref-name], ' +
               'button[data-jetpack-id="' + jetpackId + '"][pref-name]';
   let nodes = document.querySelectorAll(query);
   for (let node of nodes) {
     let name = node.getAttribute("pref-name");
     if (node.tagName == "setting") {
@@ -35,10 +34,9 @@ function onOptionsDisplayed(document, ad
     }
     else if (node.tagName == "button") {
       let label = core.get(name + "_label");
       if (label)
         node.setAttribute("label", label);
     }
   }
 }
-
-observers.add(OPTIONS_DISPLAYED, onOptionsDisplayed);
+on(OPTIONS_DISPLAYED, onOptionsDisplayed);

--- a/addon-sdk/source/lib/sdk/page-mod.js
+++ b/addon-sdk/source/lib/sdk/page-mod.js
@@ -2,17 +2,17 @@
  * 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 observers = require('./deprecated/observer-service');
+const observers = require('./system/events');
 const { Loader, validationAttributes } = require('./content/loader');
 const { Worker } = require('./content/worker');
 const { Registry } = require('./util/registry');
 const { EventEmitter } = require('./deprecated/events');
 const { on, emit } = require('./event/core');
 const { validateOptions : validate } = require('./deprecated/api-utils');
 const { Cc, Ci } = require('chrome');
 const { merge } = require('./util/object');
@@ -95,17 +95,17 @@ const PageMod = Loader.compose(EventEmit
                         ' `top` or `frame` value');
     }
     else {
       this.attachTo = ["top", "frame"];
     }
 
     let include = options.include;
     let rules = this.include = Rules();
-    
+
     if (!include)
       throw new Error('The `include` option must always contain atleast one rule');
 
     rules.add.apply(rules, [].concat(include));
 
     if (contentStyle || contentStyleFile) {
       this._style = Style({
         uri: contentStyleFile,
@@ -212,34 +212,34 @@ exports.PageMod = function(options) Page
 exports.PageMod.prototype = PageMod.prototype;
 
 const PageModManager = Registry.resolve({
   constructor: '_init',
   _destructor: '_registryDestructor'
 }).compose({
   constructor: function PageModRegistry(constructor) {
     this._init(PageMod);
-    observers.add(
+    observers.on(
       'document-element-inserted',
       this._onContentWindow = this._onContentWindow.bind(this)
     );
   },
   _destructor: function _destructor() {
-    observers.remove('document-element-inserted', this._onContentWindow);
+    observers.off('document-element-inserted', this._onContentWindow);
     this._removeAllListeners();
 
     // We need to do some cleaning er PageMods, like unregistering any
     // `contentStyle*`
     this._registry.forEach(function(pageMod) {
       pageMod.destroy();
     });
 
     this._registryDestructor();
   },
-  _onContentWindow: function _onContentWindow(document) {
+  _onContentWindow: function _onContentWindow({ subject: document }) {
     let window = document.defaultView;
     // XML documents don't have windows, and we don't yet support them.
     if (!window)
       return;
     // We apply only on documents in tabs of Firefox
     if (!getTabForContentWindow(window))
       return;
 

--- a/addon-sdk/source/lib/sdk/page-worker.js
+++ b/addon-sdk/source/lib/sdk/page-worker.js
@@ -4,18 +4,19 @@
 "use strict";
 
 module.metadata = {
   "stability": "stable"
 };
 
 const { Class } = require('./core/heritage');
 const { on, emit, off, setListeners } = require('./event/core');
-const { filter, pipe, map, merge: streamMerge } = require('./event/utils');
-const { WorkerHost, Worker, detach, attach, destroy } = require('./worker/utils');
+const { filter, pipe, map, merge: streamMerge, stripListeners } = require('./event/utils');
+const { detach, attach, destroy, WorkerHost } = require('./content/utils');
+const { Worker } = require('./content/worker');
 const { Disposable } = require('./core/disposable');
 const { EventTarget } = require('./event/target');
 const { unload } = require('./system/unload');
 const { events, streamEventsFrom } = require('./content/events');
 const { getAttachEventType } = require('./content/utils');
 const { window } = require('./addon/window');
 const { getParentWindow } = require('./window/utils');
 const { create: makeFrame, getDocShell } = require('./frame/utils');
@@ -61,18 +62,18 @@ function enableScript (page) {
 }
 
 function disableScript (page) {
   getDocShell(viewFor(page)).allowJavascript = false;
 }
 
 function Allow (page) {
   return {
-    get script() getDocShell(viewFor(page)).allowJavascript,
-    set script(value) value ? enableScript(page) : disableScript(page)
+    get script() { return getDocShell(viewFor(page)).allowJavascript; },
+    set script(value) { return value ? enableScript(page) : disableScript(page); }
   };
 }
 
 function injectWorker ({page}) {
   let worker = workerFor(page);
   let view = viewFor(page);
   if (isValidURL(page, view.contentDocument.URL))
     attach(worker, view.contentWindow);
@@ -84,42 +85,44 @@ const Page = Class({
   implements: [
     EventTarget,
     Disposable
   ],
   extends: WorkerHost(workerFor),
   setup: function Page(options) {
     let page = this;
     options = pageContract(options);
-    setListeners(this, options);
     let view = makeFrame(window.document, {
       nodeName: 'iframe',
       type: 'content',
       uri: options.contentURL,
       allowJavascript: options.allow.script,
       allowPlugins: true,
       allowAuth: true
     });
 
     ['contentScriptFile', 'contentScript', 'contentScriptWhen']
-      .forEach(function (prop) page[prop] = options[prop]);
+      .forEach(prop => page[prop] = options[prop]);
 
     views.set(this, view);
     pages.set(view, this);
 
-    let worker = new Worker(options);
+    // Set listeners on the {Page} object itself, not the underlying worker,
+    // like `onMessage`, as it gets piped
+    setListeners(this, options);
+    let worker = new Worker(stripListeners(options));
     workers.set(this, worker);
     pipe(worker, this);
 
     if (this.include || options.include) {
       this.rules = Rules();
       this.rules.add.apply(this.rules, [].concat(this.include || options.include));
     }
   },
-  get allow() Allow(this),
+  get allow() { return Allow(this); },
   set allow(value) {
     let allowJavascript = pageContract({ allow: value }).allow.script;
     return allowJavascript ? enableScript(this) : disableScript(this);
   },
   get contentURL() { return viewFor(this).getAttribute('src'); },
   set contentURL(value) {
     if (!isValidURL(this, value)) return;
     let view = viewFor(this);
@@ -128,17 +131,17 @@ const Page = Class({
   },
   dispose: function () {
     if (isDisposed(this)) return;
     let view = viewFor(this);
     if (view.parentNode) view.parentNode.removeChild(view);
     views.delete(this);
     destroy(workers.get(this));
   },
-  toString: function () '[object Page]'
+  toString: function () { return '[object Page]' }
 });
 
 exports.Page = Page;
 
 let pageEvents = streamMerge([events, streamEventsFrom(window)]);
 let readyEvents = filter(pageEvents, isReadyEvent);
 let formattedEvents = map(readyEvents, function({target, type}) {
   return { type: type, page: pageFromDoc(target) };

--- a/addon-sdk/source/lib/sdk/panel.js
+++ b/addon-sdk/source/lib/sdk/panel.js
@@ -14,27 +14,27 @@ module.metadata = {
 
 const { Ci } = require("chrome");
 const { validateOptions: valid } = require('./deprecated/api-utils');
 const { setTimeout } = require('./timers');
 const { isPrivateBrowsingSupported } = require('./self');
 const { isWindowPBSupported } = require('./private-browsing/utils');
 const { Class } = require("./core/heritage");
 const { merge } = require("./util/object");
-const { WorkerHost, Worker, detach, attach, destroy,
-        requiresAddonGlobal } = require("./worker/utils");
+const { WorkerHost, detach, attach, destroy } = require("./content/utils");
+const { Worker } = require("./content/worker");
 const { Disposable } = require("./core/disposable");
 const { contract: loaderContract } = require("./content/loader");
 const { contract } = require("./util/contract");
 const { on, off, emit, setListeners } = require("./event/core");
 const { EventTarget } = require("./event/target");
 const domPanel = require("./panel/utils");
 const { events } = require("./panel/events");
 const systemEvents = require("./system/events");
-const { filter, pipe } = require("./event/utils");
+const { filter, pipe, stripListeners } = require("./event/utils");
 const { getNodeView, getActiveView } = require("./view/core");
 const { isNil, isObject } = require("./lang/type");
 const { getAttachEventType } = require("./content/utils");
 
 let number = { is: ['number', 'undefined', 'null'] };
 let boolean = { is: ['boolean', 'undefined', 'null'] };
 
 let rectContract = contract({
@@ -112,30 +112,30 @@ const Panel = Class({
     let model = merge({
       defaultWidth: 320,
       defaultHeight: 240,
       focus: true,
       position: Object.freeze({}),
     }, panelContract(options));
     models.set(this, model);
 
-    // Setup listeners.
-    setListeners(this, options);
 
     // Setup view
     let view = domPanel.make();
     panels.set(view, this);
     views.set(this, view);
 
     // Load panel content.
     domPanel.setURL(view, model.contentURL);
 
     setupAutoHide(this);
 
-    let worker = new Worker(options);
+    // Setup listeners.
+    setListeners(this, options);
+    let worker = new Worker(stripListeners(options));
     workers.set(this, worker);
 
     // pipe events from worker to a panel.
     pipe(worker, this);
   },
   dispose: function dispose() {
     this.hide();
     off(this);

--- a/addon-sdk/source/lib/sdk/simple-prefs.js
+++ b/addon-sdk/source/lib/sdk/simple-prefs.js
@@ -3,30 +3,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 'use strict';
 
 module.metadata = {
   "stability": "experimental"
 };
 
 const { emit, off } = require("./event/core");
-const { when: unload } = require("./system/unload");
 const { PrefsTarget } = require("./preferences/event-target");
 const { id } = require("./self");
-const observers = require("./deprecated/observer-service");
+const { on } = require("./system/events");
 
 const ADDON_BRANCH = "extensions." + id + ".";
 const BUTTON_PRESSED = id + "-cmdPressed";
 
 const target = PrefsTarget({ branchName: ADDON_BRANCH });
 
 // Listen to clicks on buttons
-function buttonClick(subject, data) {
+function buttonClick({ data }) {
   emit(target, data);
 }
-observers.add(BUTTON_PRESSED, buttonClick);
-
-// Make sure we cleanup listeners on unload.
-unload(function() {
-  observers.remove(BUTTON_PRESSED, buttonClick);
-});
+on(BUTTON_PRESSED, buttonClick);
 
 module.exports = target;

--- a/addon-sdk/source/lib/sdk/test/harness.js
+++ b/addon-sdk/source/lib/sdk/test/harness.js
@@ -1,33 +1,40 @@
 /* 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, Cu } = require("chrome");
 const { Loader } = require('./loader');
 const { serializeStack, parseStack  } = require("toolkit/loader");
 const { setTimeout } = require('../timers');
-const memory = require('../deprecated/memory');
 const { PlainTextConsole } = require("../console/plain-text");
 const { when: unload } = require("../system/unload");
 const { format, fromException }  = require("../console/traceback");
 const system = require("../system");
+const memory = require('../deprecated/memory');
+const { gc: gcPromise } = require('./memory');
+const { defer } = require('../core/promise');
 
 // Trick manifest builder to make it think we need these modules ?
 const unit = require("../deprecated/unit-test");
 const test = require("../../test");
 const url = require("../url");
 
+function emptyPromise() {
+  let { promise, resolve } = defer();
+  resolve();
+  return promise;
+}
+
 var cService = Cc['@mozilla.org/consoleservice;1'].getService()
                .QueryInterface(Ci.nsIConsoleService);
 
 // The console used to log messages
 var testConsole;
 
 // Cuddlefish loader in which we load and execute tests.
 var loader;
@@ -138,67 +145,61 @@ function dictDiff(last, curr) {
     var result = curr[name] - (last[name] || 0);
     if (result)
       diff[name] = (result > 0 ? "+" : "") + result;
   }
   return diff;
 }
 
 function reportMemoryUsage() {
-  memory.gc();
-
-  var mgr = Cc["@mozilla.org/memory-reporter-manager;1"]
-            .getService(Ci.nsIMemoryReporterManager);
-
-  // Bug 916501: this code is *so* bogus -- nsIMemoryReporter changed its |memoryUsed|
-  // field to |amount| *years* ago, and even bigger changes have happened
-  // since -- that it must just never be run.
-  var reporters = mgr.enumerateReporters();
-  if (reporters.hasMoreElements())
-    print("\n");
-
-  while (reporters.hasMoreElements()) {
-    var reporter = reporters.getNext();
-    reporter.QueryInterface(Ci.nsIMemoryReporter);
-    print(reporter.description + ": " + reporter.memoryUsed + "\n");
+  if (!profileMemory) {
+    return emptyPromise();
   }
 
-  var weakrefs = [info.weakref.get()
-                  for each (info in memory.getObjects())];
-  weakrefs = [weakref for each (weakref in weakrefs) if (weakref)];
-  print("Tracked memory objects in testing sandbox: " +
-        weakrefs.length + "\n");
+  return gcPromise().then((function () {
+    var mgr = Cc["@mozilla.org/memory-reporter-manager;1"]
+              .getService(Ci.nsIMemoryReporterManager);
+    let count = 0;
+    function logReporter(process, path, kind, units, amount, description) {
+      print(((++count == 1) ? "\n" : "") + description + ": " + amount + "\n");
+    }
+    mgr.getReportsForThisProcess(logReporter, null);
+
+    var weakrefs = [info.weakref.get()
+                    for each (info in memory.getObjects())];
+    weakrefs = [weakref for each (weakref in weakrefs) if (weakref)];
+    print("Tracked memory objects in testing sandbox: " + weakrefs.length + "\n");
+  }));
 }
 
 var gWeakrefInfo;
 
 function checkMemory() {
-  memory.gc();
-  Cu.schedulePreciseGC(function () {
+  return gcPromise().then(_ => {
     let leaks = getPotentialLeaks();
 
     let compartmentURLs = Object.keys(leaks.compartments).filter(function(url) {
       return !(url in startLeaks.compartments);
     });
 
     let windowURLs = Object.keys(leaks.windows).filter(function(url) {
       return !(url in startLeaks.windows);
     });
 
     for (let url of compartmentURLs)
       console.warn("LEAKED", leaks.compartments[url]);
 
     for (let url of windowURLs)
       console.warn("LEAKED", leaks.windows[url]);
-
-    showResults();
-  });
+  }).then(showResults);
 }
 
 function showResults() {
+  let { promise, resolve } = defer();
+
   if (gWeakrefInfo) {
     gWeakrefInfo.forEach(
       function(info) {
         var ref = info.weakref.get();
         if (ref !== null) {
           var data = ref.__url__ ? ref.__url__ : ref;
           var warning = data == "[object Object]"
             ? "[object " + data.constructor.name + "(" +
@@ -206,16 +207,19 @@ function showResults() {
             : data;
           console.warn("LEAK", warning, info.bin);
         }
       }
     );
   }
 
   onDone(results);
+
+  resolve();
+  return promise;
 }
 
 function cleanup() {
   let coverObject = {};
   try {
     for (let name in loader.modules)
       memory.track(loader.modules[name],
                            "module global scope: " + name);
@@ -245,17 +249,18 @@ function cleanup() {
     if (typeof loader.globals.global == "object") {
       coverObject = loader.globals.global['__$coverObject'] || {};
     }
 
     consoleListener.errorsLogged = 0;
     loader = null;
 
     memory.gc();
-  } catch (e) {
+  }
+  catch (e) {
     results.failed++;
     console.error("unload.send() threw an exception.");
     console.exception(e);
   };
 
   setTimeout(require('@test/options').checkMemory ? checkMemory : showResults, 1);
 
   // dump the coverobject
@@ -328,34 +333,33 @@ function getPotentialLeaks() {
       if (matches[1] in compartments)
         return;
 
       let details = compartmentDetails.exec(matches[1]);
       if (!details) {
         console.error("Unable to parse compartment detail " + matches[1]);
         return;
       }
- 
+
       let item = {
         path: matches[1],
         principal: details[1],
         location: details[2] ? details[2].replace("\\", "/", "g") : undefined,
         source: details[3] ? details[3].split(" -> ").reverse() : undefined,
         toString: function() this.location
       };
 
       if (!isPossibleLeak(item))
         return;
 
       compartments[matches[1]] = item;
       return;
     }
 
-    matches = windowRegexp.exec(path);
-    if (matches) {
+    if (matches = windowRegexp.exec(path)) {
       if (matches[1] in windows)
         return;
 
       let details = windowDetails.exec(matches[1]);
       if (!details) {
         console.error("Unable to parse window detail " + matches[1]);
         return;
       }
@@ -369,45 +373,50 @@ function getPotentialLeaks() {
 
       if (!isPossibleLeak(item))
         return;
 
       windows[matches[1]] = item;
     }
   }
 
-  let mgr = Cc["@mozilla.org/memory-reporter-manager;1"].
-            getService(Ci.nsIMemoryReporterManager);
-
-  mgr.getReportsForThisProcess(logReporter, null);
+  Cc["@mozilla.org/memory-reporter-manager;1"]
+    .getService(Ci.nsIMemoryReporterManager)
+    .getReportsForThisProcess(logReporter, null);
 
   return { compartments: compartments, windows: windows };
 }
 
 function nextIteration(tests) {
   if (tests) {
     results.passed += tests.passed;
     results.failed += tests.failed;
 
-    if (profileMemory)
-      reportMemoryUsage();
+    reportMemoryUsage().then(_ => {
+      let testRun = [];
+      for each (let test in tests.testRunSummary) {
+        let testCopy = {};
+        for (let info in test) {
+          testCopy[info] = test[info];
+        }
+        testRun.push(testCopy);
+      }
 
-    let testRun = [];
-    for each (let test in tests.testRunSummary) {
-      let testCopy = {};
-      for (let info in test) {
-        testCopy[info] = test[info];
-      }
-      testRun.push(testCopy);
-    }
+      results.testRuns.push(testRun);
+      iterationsLeft--;
 
-    results.testRuns.push(testRun);
-    iterationsLeft--;
+      checkForEnd();
+    })
   }
+  else {
+    checkForEnd();
+  }
+}
 
+function checkForEnd() {
   if (iterationsLeft && (!stopOnError || results.failed == 0)) {
     // Pass the loader which has a hooked console that doesn't dispatch
     // errors to the JS console and avoid firing false alarm in our
     // console listener
     findAndRunTests(loader, nextIteration);
   }
   else {
     setTimeout(cleanup, 0);