Introduce a Link that allows console messages and breaking with the debugger.

Author: Paul Ellenbogen

Gruntfile.js

@@ -53,7 +53,7 @@ module.exports = function(grunt) {
           FILES.lib
             .concat(promise_lib)
             .concat(FILES.srcCore)
-            .concat("src/tab-link.js")
+            .concat("src/backgroundframe-link.js")
             .concat('providers/*.js')
         }
       }

README.md

@@ -18,10 +18,12 @@ Or in classic firefox extensions use:
     Components.utils.import(PATH TO .jsm);
 
 
-This will define the function `setupFreedom` in the current scope. `setupFreedom` takes three arguments:
-- manifest: the path to the freedom manifest file.
-- debug: true for debugging output.
-- freedomcfg: the freedomcfg function for defining new freedom apis.
+This will define the function `setupFreedom` in the current scope. `setupFreedom` takes two arguments:
+  - manifest: the path to the freedom manifest file.
+  - options: an dictionary mapping various options
+    - debug: true for debugging output.
+    - freedomcfg: the freedomcfg function for defining new freedom apis.
+    - portType: Type of port. Default is Worker. BackgroundFrame is available for debugging purposes.
 
 `setupFreedom` returns a freedom object.
 

src/tab-link.js src/backgroundframe-link.jssrc/tab-link.js renamed to src/backgroundframe-link.js

@@ -6,56 +6,59 @@ if (typeof fdom === 'undefined') {
 fdom.link = fdom.link || {};
 
 /**
- * A port providing message transport between two freedom contexts via iTabs.
- * @class link.Tab
+ * A port providing message transport between two freedom contexts via iBackgroundFrames.
+ * @class link.BackgroundFrame
  * @extends Link
  * @uses handleEvents
  * @constructor
  */
-fdom.link.Tab = function() {
+fdom.link.BackgroundFrame = function() {
   fdom.Link.call(this);
+  if (typeof hiddenWindow !== 'undefined') {
+    this.document = hiddenWindow.document;
+  }
 };
 
 /**
- * Start this port by listening or creating a tab.
+ * Start this port by listening or creating a frame.
  * @method start
  * @private
  */
-fdom.link.Tab.prototype.start = function() {
+fdom.link.BackgroundFrame.prototype.start = function() {
   if (this.config.moduleContext) {
     this.config.global.DEBUG = true;
     this.setupListener();
     this.src = 'in';
   } else {
-    this.setupTab();
+    this.setupBackgroundFrame();
     this.src = 'out';
   }
 };
 
 /**
- * Stop this port by deleting the tab.
+ * Stop this port by deleting the frame.
  * @method stop
  * @private
  */
-fdom.link.Tab.prototype.stop = function() {
-  // Function is determined by setupListener or setupTab as appropriate.
+fdom.link.BackgroundFrame.prototype.stop = function() {
+  // Function is determined by setupListener or setupBackgroundFrame as appropriate.
 };
 
 /**
  * Get the textual description of this port.
  * @method toString
  * @return {String} the description of this port.
  */
-fdom.link.Tab.prototype.toString = function() {
-  return "[Tab" + this.id + "]";
+fdom.link.BackgroundFrame.prototype.toString = function() {
+  return "[BackgroundFrame" + this.id + "]";
 };
 
 /**
  * Set up a global listener to handle incoming messages to this
  * freedom.js context.
  * @method setupListener
  */
-fdom.link.Tab.prototype.setupListener = function() {
+fdom.link.BackgroundFrame.prototype.setupListener = function() {
   var onMsg = function(msg) {
     if (msg.data.src !== 'in') {
       this.emitMessage(msg.data.flow, msg.data.message);
@@ -71,72 +74,66 @@ fdom.link.Tab.prototype.setupListener = function() {
 };
 
 /**
- * Set up an iTab with an isolated freedom.js context inside.
- * @method setupTab
+ * Set up an iBackgroundFrame with an isolated freedom.js context inside.
+ * @method setupBackgroundFrame
  */
-fdom.link.Tab.prototype.setupTab = function() {
-  var worker, onMsg;
-  worker = this.makeTab(this.config.src, this.config.inject);
+fdom.link.BackgroundFrame.prototype.setupBackgroundFrame = function() {
+  var frame, onMsg;
+  frame = this.makeBackgroundFrame(this.config.src, this.config.inject);
 
-  onMsg = function(tab, msg) {
+  if (!this.document.body) {
+    this.document.appendChild(this.document.createElement("body"));
+  }
+  this.document.body.appendChild(frame);
+
+  onMsg = function(frame, msg) {
     if (!this.obj) {
-      this.obj = tab;
+      this.obj = frame;
       this.emit('started');
     }
     if (msg.data.src !== 'out') {
       this.emitMessage(msg.data.flow, msg.data.message);
     }
-  }.bind(this, worker);
+  }.bind(this, frame.contentWindow);
 
-  worker.port.on('message', onMsg);
+  frame.contentWindow.addEventListener('message', onMsg, true);
   this.stop = function() {
-    worker.destroy();
+    frame.contentWindow.removeEventListener('message', onMsg, true);
     if (this.obj) {
       delete this.obj;
     }
+    frame.src = "about:blank";
+    this.document.body.removeChild(frame);
   };
 };
 
-// The toString version of this function will be used as a content script
-fdom.link.contentScript = function contentScript() {
-  var window = unsafeWindow;
-  window.addEventListener("message", self.port.emit.bind(self.port, "message"));
-  self.port.on("message", function(message) {
-    window.postMessage(message, "*");
-  });
-};
-
 /**
- * Make tabs to replicate freedom isolation without web-workers.
- * iTab isolation is non-standardized, and access to the DOM within tabs
+ * Make frames to replicate freedom isolation without web-workers.
+ * iBackgroundFrame isolation is non-standardized, and access to the DOM within frames
  * means that they are insecure. However, debugging of webworkers is
  * painful enough that this mode of execution can be valuable for debugging.
- * @method makeTab
+ * @method makeBackgroundFrame
  */
-fdom.link.Tab.prototype.makeTab = function(src) {
-  debugger;
-  var tab,
+fdom.link.BackgroundFrame.prototype.makeBackgroundFrame = function(src, inject) {
+  var frame = this.document.createElement('iframe'),
       extra = '',
       loader,
-      worker,
       blob;
   // TODO(willscott): add sandboxing protection.
 
   // TODO(willscott): survive name mangling.
-  src = src.replace('portType: "Worker"', 'portType: "Tab"');
+  src = src.replace('portType: "Worker"', 'portType: "BackgroundFrame"');
+  if (inject) {
+    extra = '<script src="' + inject + '" onerror="' +
+      'throw new Error(\'Injection of ' + inject +' Failed!\');' +
+      '"></script>';
+  }
   loader = '<html>' + extra + '<script src="' +
       fdom.util.forceModuleContext(src) + '"></script></html>';
   blob = fdom.util.getBlob(loader, 'text/html');
-  tab = fftabs.open({url: fdom.util.getURL(blob),
-                          onLoad: function onLoad(tab) {
-                            worker = tab.attach({
-                              contentScript: "(" +
-                                fdom.link.contentScript.toString() +
-                                ")()"
-                            });
-                          }});
-  
-  return worker;
+  frame.src = fdom.util.getURL(blob);
+
+  return frame;
 };
 
 /**
@@ -146,15 +143,9 @@ fdom.link.Tab.prototype.makeTab = function(src) {
  * @param {String} flow the channel/flow of the message.
  * @param {Object} message The Message.
  */
-fdom.link.Tab.prototype.deliverMessage = function(flow, message) {
-  if (this.obj.port) { // We are in the root context
+fdom.link.BackgroundFrame.prototype.deliverMessage = function(flow, message) {
+  if (this.obj) {
     //fdom.debug.log('message sent to worker: ', flow, message);
-    this.obj.port.emit("message", {
-      src: this.src,
-      flow: flow,
-      message: message
-    });
-  } else if(this.obj.postMessage) { // We are in a module
     this.obj.postMessage({
       src: this.src,
       flow: flow,
@@ -164,3 +155,4 @@ fdom.link.Tab.prototype.deliverMessage = function(flow, message) {
     this.once('started', this.onMessage.bind(this, flow, message));
   }
 };
+

src/firefox-preamble.js

@@ -4,13 +4,12 @@ Components.utils.import('resource://gre/modules/Services.jsm');
 // This module does not support all of es6 promise functionality.
 // Components.utils.import("resource://gre/modules/Promise.jsm");
 const XMLHttpRequest = Components.Constructor("@mozilla.org/xmlextras/xmlhttprequest;1", "nsIXMLHttpRequest");
-Components.utils.importGlobalProperties(['URL']);
+
 
 var hiddenWindow = Services.appShell.hiddenDOMWindow;
 var mozRTCPeerConnection = hiddenWindow.mozRTCPeerConnection;
 var mozRTCSessionDescription = hiddenWindow.mozRTCSessionDescription;
 var mozRTCIceCandidate = hiddenWindow.mozRTCIceCandidate;
-
 // Replace Blob with blob that has prototype defined.
 // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1007318
 var Blob = hiddenWindow.Blob;
@@ -23,21 +22,36 @@ var location = {
   protocol: "resource:"
 };
 
-function setupFreedom(manifest, debug, freedomcfg, fftabs) {
+function setupFreedom(manifest, options) {
+  debugger;
   if (this.freedom) {
     return this.freedom;
   }
 
+  options = options || {};
+  var freedomcfg = options.freedomcfg;
+
+
+  if (options.portType === "BackgroundFrame") {
+    // If we are using iframes on the background page, we need to
+    // generate blob URLs from the URL object on the page. We get a
+    // privledge error if we try to load a blob given a url by the
+    // Cu.importGlobalProperties(['URL']) version of URL.
+    var URL = hiddenWindow.URL;
+  } else {
+    Components.utils.importGlobalProperties(['URL']);
+  }
+
   var lastSlash = manifest.lastIndexOf("/");
   var manifestLocation = manifest.substring(0, lastSlash + 1);
   //var manifestFilename = manifest.substring(lastSlash + 1);
   firefox_config = {
     isApp: false,
     manifest: manifest,
-    portType: 'Tab',
+    portType: options.portType || 'Worker',
     stayLocal: true,
     location: manifestLocation,
-    debug: debug || false,
+    debug: options.debug || false,
     isModule: false
   };