The Tor Browser: addon-sdk/source/lib/sdk/deprecated/symbiont.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/deprecated/symbiont.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/deprecated/symbiont.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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;