The Tor Browser: comparison addon-sdk/source/lib/sdk/content/worker.js

comparison: addon-sdk/source/lib/sdk/content/worker.js

addon-sdk/source/lib/sdk/content/worker.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:d2a0b67e63a0
+/* 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, setListeners } = require('../event/core');
+const {
+attach, detach, destroy
+} = require('./utils');
+const { method } = require('../lang/functional');
+const { Ci, Cu, Cc } = require('chrome');
+const unload = require('../system/unload');
+const events = require('../system/events');
+const { getInnerId } = require("../window/utils");
+const { WorkerSandbox } = require('./sandbox');
+const { getTabForWindow } = require('../tabs/helpers');
+// A weak map of workers to hold private attributes that
+// should not be exposed
+const workers = new WeakMap();
+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.";
+/**
+* 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 = 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 || {};
+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 model = modelFor(this);
+let args = ['message'].concat(data);
+if (!model.inited) {
+model.earlyEvents.push(args);
+return;
+}
+processMessage.apply(null, [this].concat(args));
+},
+get url () {
+let model = modelFor(this);
+// model.window will be null after detach
+return model.window ? model.window.document.location.href : null;
+},
+get contentURL () {
+let model = modelFor(this);
+return model.window ? model.window.document.URL : null;
+},
+get tab () {
+let model = modelFor(this);
+// model.window will be null after detach
+if (model.window)
+return getTabForWindow(model.window);
+return null;
+},
+// Implemented to provide some of the previous features of exposing sandbox
+// so that Worker can be extended
+getSandbox: function () {
+return modelFor(this).contentWorker;
+},
+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);
+// 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);
+// Mainly enable worker.port.emit to send event to the content worker
+model.inited = true;
+model.frozen = false;
+// Fire off `attach` event
+emit(worker, 'attach', window);
+// Process all events and messages that were fired before the
+// worker was initialized.
+model.earlyEvents.forEach(args => processMessage.apply(null, [worker].concat(args)));
+});
+/**
+* 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, reason) {
+let model = modelFor(worker);
+// maybe unloaded before content side is created
+if (model.contentWorker) {
+model.contentWorker.destroy(reason);
+}
+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, reason) {
+detach(worker, reason);
+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 (worker, ...args) {
+let model = modelFor(worker) || {};
+if (!model.contentWorker)
+throw new Error(ERR_DESTROYED);
+if (model.frozen)
+throw new Error(ERR_FROZEN);
+model.contentWorker.emit.apply(null, args);
+}
+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));
+}