The Tor Browser: addon-sdk/source/lib/sdk/widget.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/widget.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/widget.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* 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";
 // The widget module currently supports only Firefox.
 // See: https://bugzilla.mozilla.org/show_bug.cgi?id=560716
 module.metadata = {
   "stability": "deprecated",
   "engines": {
     "Firefox": "*"
   }
 };
 // Widget content types
 const CONTENT_TYPE_URI    = 1;
 const CONTENT_TYPE_HTML   = 2;
 const CONTENT_TYPE_IMAGE  = 3;
 const ERR_CONTENT = "No content or contentURL property found. Widgets must "
                          + "have one or the other.",
       ERR_LABEL = "The widget must have a non-empty label property.",
       ERR_ID = "You have to specify a unique value for the id property of " +
                "your widget in order for the application to remember its " +
                "position.",
       ERR_DESTROYED = "The widget has been destroyed and can no longer be used.";
 const INSERTION_PREF_ROOT = "extensions.sdk-widget-inserted.";
 // Supported events, mapping from DOM event names to our event names
 const EVENTS = {
   "click": "click",
   "mouseover": "mouseover",
   "mouseout": "mouseout",
 };
 // In the Australis menu panel, normally widgets should be treated like
 // normal toolbarbuttons. If they're any wider than this margin, we'll
 // treat them as wide widgets instead, which fill up the width of the panel:
 const AUSTRALIS_PANEL_WIDE_WIDGET_CUTOFF = 70;
 const AUSTRALIS_PANEL_WIDE_CLASSNAME = "panel-wide-item";
 const { validateOptions } = require("./deprecated/api-utils");
 const panels = require("./panel");
 const { EventEmitter, EventEmitterTrait } = require("./deprecated/events");
 const { Trait } = require("./deprecated/traits");
 const LightTrait = require('./deprecated/light-traits').Trait;
 const { Loader, Symbiont } = require("./content/content");
 const { Cortex } = require('./deprecated/cortex');
 const windowsAPI = require("./windows");
 const { WindowTracker } = require("./deprecated/window-utils");
 const { isBrowser } = require("./window/utils");
 const { setTimeout } = require("./timers");
 const unload = require("./system/unload");
 const { getNodeView } = require("./view/core");
 const prefs = require('./preferences/service');
 require("./util/deprecate").deprecateUsage(
   "The widget module is deprecated.  " +
   "Please consider using the sdk/ui module instead."
 );
 // Data types definition
 const valid = {
   number: { is: ["null", "undefined", "number"] },
   string: { is: ["null", "undefined", "string"] },
   id: {
     is: ["string"],
     ok: function (v) v.length > 0,
     msg: ERR_ID,
     readonly: true
   },
   label: {
     is: ["string"],
     ok: function (v) v.length > 0,
     msg: ERR_LABEL
   },
   panel: {
     is: ["null", "undefined", "object"],
     ok: function(v) !v || v instanceof panels.Panel
   },
   width: {
     is: ["null", "undefined", "number"],
     map: function (v) {
       if (null === v || undefined === v) v = 16;
       return v;
     },
     defaultValue: 16
   },
   allow: {
     is: ["null", "undefined", "object"],
     map: function (v) {
       if (!v) v = { script: true };
       return v;
     },
     get defaultValue() ({ script: true })
   },
 };
 // Widgets attributes definition
 let widgetAttributes = {
   label: valid.label,
   id: valid.id,
   tooltip: valid.string,
   width: valid.width,
   content: valid.string,
   panel: valid.panel,
   allow: valid.allow
 };
 // Import data definitions from loader, but don't compose with it as Model
 // functions allow us to recreate easily all Loader code.
 let loaderAttributes = require("./content/loader").validationAttributes;
 for (let i in loaderAttributes)
   widgetAttributes[i] = loaderAttributes[i];
 widgetAttributes.contentURL.optional = true;
 // Widgets public events list, that are automatically binded in options object
 const WIDGET_EVENTS = [
   "click",
   "mouseover",
   "mouseout",
   "error",
   "message",
   "attach"
 ];
 // `Model` utility functions that help creating these various Widgets objects
 let model = {
   // Validate one attribute using api-utils.js:validateOptions function
   _validate: function _validate(name, suspect, validation) {
     let $1 = {};
     $1[name] = suspect;
     let $2 = {};
     $2[name] = validation;
     return validateOptions($1, $2)[name];
   },
   /**
    * This method has two purposes:
    * 1/ Validate and define, on a given object, a set of attribute
    * 2/ Emit a "change" event on this object when an attribute is changed
    *
    * @params {Object} object
    *    Object on which we can bind attributes on and watch for their changes.
    *    This object must have an EventEmitter interface, or, at least `_emit`
    *    method
    * @params {Object} attrs
    *    Dictionary of attributes definition following api-utils:validateOptions
    *    scheme
    * @params {Object} values
    *    Dictionary of attributes default values
    */
   setAttributes: function setAttributes(object, attrs, values) {
     let properties = {};
     for (let name in attrs) {
       let value = values[name];
       let req = attrs[name];
       // Retrieve default value from typedef if the value is not defined
       if ((typeof value == "undefined" || value == null) && req.defaultValue)
         value = req.defaultValue;
       // Check for valid value if value is defined or mandatory
       if (!req.optional || typeof value != "undefined")
         value = model._validate(name, value, req);
       // In any case, define this property on `object`
       let property = null;
       if (req.readonly) {
         property = {
           value: value,
           writable: false,
           enumerable: true,
           configurable: false
         };
       }
       else {
         property = model._createWritableProperty(name, value);
       }
       properties[name] = property;
     }
     Object.defineProperties(object, properties);
   },
   // Generate ES5 property definition for a given attribute
   _createWritableProperty: function _createWritableProperty(name, value) {
     return {
       get: function () {
         return value;
       },
       set: function (newValue) {
         value = newValue;
         // The main goal of all this Model stuff is here:
         // We want to forward all changes to some listeners
         this._emit("change", name, value);
       },
       enumerable: true,
       configurable: false
     };
   },
   /**
    * Automagically register listeners in options dictionary
    * by detecting listener attributes with name starting with `on`
    *
    * @params {Object} object
    *    Target object that need to follow EventEmitter interface, or, at least,
    *    having `on` method.
    * @params {Array} events
    *    List of events name to automatically bind.
    * @params {Object} listeners
    *    Dictionary of event listener functions to register.
    */
   setEvents: function setEvents(object, events, listeners) {
     for (let i = 0, l = events.length; i < l; i++) {
       let name = events[i];
       let onName = "on" + name[0].toUpperCase() + name.substr(1);
       if (!listeners[onName])
         continue;
       object.on(name, listeners[onName].bind(object));
     }
   }
 };
 function saveInserted(widgetId) {
   prefs.set(INSERTION_PREF_ROOT + widgetId, true);
 }
 function haveInserted(widgetId) {
   return prefs.has(INSERTION_PREF_ROOT + widgetId);
 }
 const isWide = node => node.classList.contains(AUSTRALIS_PANEL_WIDE_CLASSNAME);
 /**
  * Main Widget class: entry point of the widget API
  *
  * Allow to control all widget across all existing windows with a single object.
  * Widget.getView allow to retrieve a WidgetView instance to control a widget
  * specific to one window.
  */
 const WidgetTrait = LightTrait.compose(EventEmitterTrait, LightTrait({
   _initWidget: function _initWidget(options) {
     model.setAttributes(this, widgetAttributes, options);
     browserManager.validate(this);
     // We must have at least content or contentURL defined
     if (!(this.content || this.contentURL))
       throw new Error(ERR_CONTENT);
     this._views = [];
     // Set tooltip to label value if we don't have tooltip defined
     if (!this.tooltip)
       this.tooltip = this.label;
     model.setEvents(this, WIDGET_EVENTS, options);
     this.on('change', this._onChange.bind(this));
     let self = this;
     this._port = EventEmitterTrait.create({
       emit: function () {
         let args = arguments;
         self._views.forEach(function(v) v.port.emit.apply(v.port, args));
       }
     });
     // expose wrapped port, that exposes only public properties.
     this._port._public = Cortex(this._port);
     // Register this widget to browser manager in order to create new widget on
     // all new windows
     browserManager.addItem(this);
   },
   _onChange: function _onChange(name, value) {
     // Set tooltip to label value if we don't have tooltip defined
     if (name == 'tooltip' && !value) {
       // we need to change tooltip again in order to change the value of the
       // attribute itself
       this.tooltip = this.label;
       return;
     }
     // Forward attributes changes to WidgetViews
     if (['width', 'tooltip', 'content', 'contentURL'].indexOf(name) != -1) {
       this._views.forEach(function(v) v[name] = value);
     }
   },
   _onEvent: function _onEvent(type, eventData) {
     this._emit(type, eventData);
   },
   _createView: function _createView() {
     // Create a new WidgetView instance
     let view = WidgetView(this);
     // Keep a reference to it
     this._views.push(view);
     return view;
   },
   // a WidgetView instance is destroyed
   _onViewDestroyed: function _onViewDestroyed(view) {
     let idx = this._views.indexOf(view);
     this._views.splice(idx, 1);
   },
   /**
    * Called on browser window closed, to destroy related WidgetViews
    * @params {ChromeWindow} window
    *         Window that has been closed
    */
   _onWindowClosed: function _onWindowClosed(window) {
     for each (let view in this._views) {
       if (view._isInChromeWindow(window)) {
         view.destroy();
         break;
       }
     }
   },
   /**
    * Get the WidgetView instance related to a BrowserWindow instance
    * @params {BrowserWindow} window
    *         BrowserWindow reference from "windows" module
    */
   getView: function getView(window) {
     for each (let view in this._views) {
       if (view._isInWindow(window)) {
         return view._public;
       }
     }
     return null;
   },
   get port() this._port._public,
   set port(v) {}, // Work around Cortex failure with getter without setter
                   // See bug 653464
   _port: null,
   postMessage: function postMessage(message) {
     this._views.forEach(function(v) v.postMessage(message));
   },
   destroy: function destroy() {
     if (this.panel)
       this.panel.destroy();
     // Dispatch destroy calls to views
     // we need to go backward as we remove items from this array in
     // _onViewDestroyed
     for (let i = this._views.length - 1; i >= 0; i--)
       this._views[i].destroy();
     // Unregister widget to stop creating it over new windows
     // and allow creation of new widget with same id
     browserManager.removeItem(this);
   }
 }));
 // Widget constructor
 const Widget = function Widget(options) {
   let w = WidgetTrait.create(Widget.prototype);
   w._initWidget(options);
   // Return a Cortex of widget in order to hide private attributes like _onEvent
   let _public = Cortex(w);
   unload.ensure(_public, "destroy");
   return _public;
 }
 exports.Widget = Widget;
 /**
  * WidgetView is an instance of a widget for a specific window.
  *
  * This is an external API that can be retrieved by calling Widget.getView or
  * by watching `attach` event on Widget.
  */
 const WidgetViewTrait = LightTrait.compose(EventEmitterTrait, LightTrait({
   // Reference to the matching WidgetChrome
   // set right after constructor call
   _chrome: null,
   // Public interface of the WidgetView, passed in `attach` event or in
   // Widget.getView
   _public: null,
   _initWidgetView: function WidgetView__initWidgetView(baseWidget) {
     this._baseWidget = baseWidget;
     model.setAttributes(this, widgetAttributes, baseWidget);
     this.on('change', this._onChange.bind(this));
     let self = this;
     this._port = EventEmitterTrait.create({
       emit: function () {
         if (!self._chrome)
           throw new Error(ERR_DESTROYED);
         self._chrome.update(self._baseWidget, "emit", arguments);
       }
     });
     // expose wrapped port, that exposes only public properties.
     this._port._public = Cortex(this._port);
     this._public = Cortex(this);
   },
   // Called by WidgetChrome, when the related Worker is applied to the document,
   // so that we can start sending events to it
   _onWorkerReady: function () {
     // Emit an `attach` event with a WidgetView instance without private attrs
     this._baseWidget._emit("attach", this._public);
   },
   _onChange: function WidgetView__onChange(name, value) {
     if (name == 'tooltip' && !value) {
       this.tooltip = this.label;
       return;
     }
     // Forward attributes changes to WidgetChrome instance
     if (['width', 'tooltip', 'content', 'contentURL'].indexOf(name) != -1) {
       this._chrome.update(this._baseWidget, name, value);
     }
   },
   _onEvent: function WidgetView__onEvent(type, eventData, domNode) {
     // Dispatch event in view
     this._emit(type, eventData);
     // And forward it to the main Widget object
     if ("click" == type || type.indexOf("mouse") == 0)
       this._baseWidget._onEvent(type, this._public);
     else
       this._baseWidget._onEvent(type, eventData);
     // Special case for click events: if the widget doesn't have a click
     // handler, but it does have a panel, display the panel.
     if ("click" == type && !this._listeners("click").length && this.panel) {
       // This kind of ugly workaround, instead we should implement
       // `getNodeView` for the `Widget` class itself, but that's kind of
       // hard without cleaning things up.
       this.panel.show(null, getNodeView.implement({}, () => domNode));
     }
   },
   _isInWindow: function WidgetView__isInWindow(window) {
     return windowsAPI.BrowserWindow({
       window: this._chrome.window
     }) == window;
   },
   _isInChromeWindow: function WidgetView__isInChromeWindow(window) {
     return this._chrome.window == window;
   },
   _onPortEvent: function WidgetView__onPortEvent(args) {
     let port = this._port;
     port._emit.apply(port, args);
     let basePort = this._baseWidget._port;
     basePort._emit.apply(basePort, args);
   },
   get port() this._port._public,
   set port(v) {}, // Work around Cortex failure with getter without setter
                   // See bug 653464
   _port: null,
   postMessage: function WidgetView_postMessage(message) {
     if (!this._chrome)
       throw new Error(ERR_DESTROYED);
     this._chrome.update(this._baseWidget, "postMessage", message);
   },
   destroy: function WidgetView_destroy() {
     this._chrome.destroy();
     delete this._chrome;
     this._baseWidget._onViewDestroyed(this);
     this._emit("detach");
   }
 }));
 const WidgetView = function WidgetView(baseWidget) {
   let w = WidgetViewTrait.create(WidgetView.prototype);
   w._initWidgetView(baseWidget);
   return w;
 }
 /**
  * Keeps track of all browser windows.
  * Exposes methods for adding/removing widgets
  * across all open windows (and future ones).
  * Create a new instance of BrowserWindow per window.
  */
 let browserManager = {
   items: [],
   windows: [],
   // Registers the manager to listen for window openings and closings.  Note
   // that calling this method can cause onTrack to be called immediately if
   // there are open windows.
   init: function () {
     let windowTracker = new WindowTracker(this);
     unload.ensure(windowTracker);
   },
   // Registers a window with the manager.  This is a WindowTracker callback.
   onTrack: function browserManager_onTrack(window) {
     if (isBrowser(window)) {
       let win = new BrowserWindow(window);
       win.addItems(this.items);
       this.windows.push(win);
     }
   },
   // Unregisters a window from the manager.  It's told to undo all
   // modifications.  This is a WindowTracker callback.  Note that when
   // WindowTracker is unloaded, it calls onUntrack for every currently opened
   // window.  The browserManager therefore doesn't need to specially handle
   // unload itself, since unloading the browserManager means untracking all
   // currently opened windows.
   onUntrack: function browserManager_onUntrack(window) {
     if (isBrowser(window)) {
       this.items.forEach(function(i) i._onWindowClosed(window));
       for (let i = 0; i < this.windows.length; i++) {
         if (this.windows[i].window == window) {
           this.windows.splice(i, 1)[0];
           return;
         }
       }
     }
   },
   // Used to validate widget by browserManager before adding it,
   // in order to check input very early in widget constructor
   validate : function (item) {
     let idx = this.items.indexOf(item);
     if (idx > -1)
       throw new Error("The widget " + item + " has already been added.");
     if (item.id) {
       let sameId = this.items.filter(function(i) i.id == item.id);
       if (sameId.length > 0)
         throw new Error("This widget ID is already used: " + item.id);
     } else {
       item.id = this.items.length;
     }
   },
   // Registers an item with the manager. It's added to all currently registered
   // windows, and when new windows are registered it will be added to them, too.
   addItem: function browserManager_addItem(item) {
     this.items.push(item);
     this.windows.forEach(function (w) w.addItems([item]));
   },
   // Unregisters an item from the manager.  It's removed from all windows that
   // are currently registered.
   removeItem: function browserManager_removeItem(item) {
     let idx = this.items.indexOf(item);
     if (idx > -1)
       this.items.splice(idx, 1);
   },
   propagateCurrentset: function browserManager_propagateCurrentset(id, currentset) {
     this.windows.forEach(function (w) w.doc.getElementById(id).setAttribute("currentset", currentset));
   }
 };
 /**
  * Keeps track of a single browser window.
  *
  * This is where the core of how a widget's content is added to a window lives.
  */
 function BrowserWindow(window) {
   this.window = window;
   this.doc = window.document;
 }
 BrowserWindow.prototype = {
   // Adds an array of items to the window.
   addItems: function BW_addItems(items) {
     items.forEach(this._addItemToWindow, this);
   },
   _addItemToWindow: function BW__addItemToWindow(baseWidget) {
     // Create a WidgetView instance
     let widget = baseWidget._createView();
     // Create a WidgetChrome instance
     let item = new WidgetChrome({
       widget: widget,
       doc: this.doc,
       window: this.window
     });
     widget._chrome = item;
     this._insertNodeInToolbar(item.node);
     // We need to insert Widget DOM Node before finishing widget view creation
     // (because fill creates an iframe and tries to access its docShell)
     item.fill();
   },
   _insertNodeInToolbar: function BW__insertNodeInToolbar(node) {
     // Add to the customization palette
     let toolbox = this.doc.getElementById("navigator-toolbox");
     let palette = toolbox.palette;
     palette.appendChild(node);
     let { CustomizableUI } = this.window;
     let { id } = node;
     let placement = CustomizableUI.getPlacementOfWidget(id);
     if (!placement) {
       if (haveInserted(id) || isWide(node))
         return;
       placement = {area: 'nav-bar', position: undefined};
       saveInserted(id);
     }
     CustomizableUI.addWidgetToArea(id, placement.area, placement.position);
     CustomizableUI.ensureWidgetPlacedInWindow(id, this.window);
   }
 }
 /**
  * Final Widget class that handles chrome DOM Node:
  *  - create initial DOM nodes
  *  - receive instruction from WidgetView through update method and update DOM
  *  - watch for DOM events and forward them to WidgetView
  */
 function WidgetChrome(options) {
   this.window = options.window;
   this._doc = options.doc;
   this._widget = options.widget;
   this._symbiont = null; // set later
   this.node = null; // set later
   this._createNode();
 }
 // Update a property of a widget.
 WidgetChrome.prototype.update = function WC_update(updatedItem, property, value) {
   switch(property) {
     case "contentURL":
     case "content":
       this.setContent();
       break;
     case "width":
       this.node.style.minWidth = value + "px";
       this.node.querySelector("iframe").style.width = value + "px";
       break;
     case "tooltip":
       this.node.setAttribute("tooltiptext", value);
       break;
     case "postMessage":
       this._symbiont.postMessage(value);
       break;
     case "emit":
       let port = this._symbiont.port;
       port.emit.apply(port, value);
       break;
   }
 }
 // Add a widget to this window.
 WidgetChrome.prototype._createNode = function WC__createNode() {
   // XUL element container for widget
   let node = this._doc.createElement("toolbaritem");
   // Temporary work around require("self") failing on unit-test execution ...
   let jetpackID = "testID";
   try {
     jetpackID = require("./self").id;
   } catch(e) {}
   // Compute an unique and stable widget id with jetpack id and widget.id
   let id = "widget:" + jetpackID + "-" + this._widget.id;
   node.setAttribute("id", id);
   node.setAttribute("label", this._widget.label);
   node.setAttribute("tooltiptext", this._widget.tooltip);
   node.setAttribute("align", "center");
   // Bug 626326: Prevent customize toolbar context menu to appear
   node.setAttribute("context", "");
   // For use in styling by the browser
   node.setAttribute("sdkstylewidget", "true");
   if (this._widget.width > AUSTRALIS_PANEL_WIDE_WIDGET_CUTOFF) {
     node.classList.add(AUSTRALIS_PANEL_WIDE_CLASSNAME);
   }
   // TODO move into a stylesheet, configurable by consumers.
   // Either widget.style, exposing the style object, or a URL
   // (eg, can load local stylesheet file).
   node.setAttribute("style", [
       "overflow: hidden; margin: 1px 2px 1px 2px; padding: 0px;",
       "min-height: 16px;",
   ].join(""));
   node.style.minWidth = this._widget.width + "px";
   this.node = node;
 }
 // Initial population of a widget's content.
 WidgetChrome.prototype.fill = function WC_fill() {
   let { node, _doc: document } = this;
   // Create element
   let iframe = document.createElement("iframe");
   iframe.setAttribute("type", "content");
   iframe.setAttribute("transparent", "transparent");
   iframe.style.overflow = "hidden";
   iframe.style.height = "16px";
   iframe.style.maxHeight = "16px";
   iframe.style.width = this._widget.width + "px";
   iframe.setAttribute("flex", "1");
   iframe.style.border = "none";
   iframe.style.padding = "0px";
   // Do this early, because things like contentWindow are null
   // until the node is attached to a document.
   node.appendChild(iframe);
   let label = document.createElement("label");
   label.setAttribute("value", this._widget.label);
   label.className = "toolbarbutton-text";
   label.setAttribute("crop", "right");
   label.setAttribute("flex", "1");
   node.appendChild(label);
   // This toolbarbutton is created to provide a more consistent user experience
   // during customization, see:
   // https://bugzilla.mozilla.org/show_bug.cgi?id=959640
   let button = document.createElement("toolbarbutton");
   button.setAttribute("label", this._widget.label);
   button.setAttribute("crop", "right");
   button.className = "toolbarbutton-1 chromeclass-toolbar-additional";
   node.appendChild(button);
   // add event handlers
   this.addEventHandlers();
   // set content
   this.setContent();
 }
 // Get widget content type.
 WidgetChrome.prototype.getContentType = function WC_getContentType() {
   if (this._widget.content)
     return CONTENT_TYPE_HTML;
   return (this._widget.contentURL && /\.(jpg|gif|png|ico|svg)$/i.test(this._widget.contentURL))
     ? CONTENT_TYPE_IMAGE : CONTENT_TYPE_URI;
 }
 // Set widget content.
 WidgetChrome.prototype.setContent = function WC_setContent() {
   let type = this.getContentType();
   let contentURL = null;
   switch (type) {
     case CONTENT_TYPE_HTML:
       contentURL = "data:text/html;charset=utf-8," + encodeURIComponent(this._widget.content);
       break;
     case CONTENT_TYPE_URI:
       contentURL = this._widget.contentURL;
       break;
     case CONTENT_TYPE_IMAGE:
       let imageURL = this._widget.contentURL;
       contentURL = "data:text/html;charset=utf-8,<html><body><img src='" +
                    encodeURI(imageURL) + "'></body></html>";
       break;
     default:
       throw new Error("The widget's type cannot be determined.");
   }
   let iframe = this.node.firstElementChild;
   let self = this;
   // Cleanup previously created symbiont (in case we are update content)
   if (this._symbiont)
     this._symbiont.destroy();
   this._symbiont = Trait.compose(Symbiont.resolve({
     _onContentScriptEvent: "_onContentScriptEvent-not-used",
     _onInit: "_initSymbiont"
   }), {
     // Overload `Symbiont._onInit` in order to know when the related worker
     // is ready.
     _onInit: function () {
       this._initSymbiont();
       self._widget._onWorkerReady();
     },
     _onContentScriptEvent: function () {
       // Redirect events to WidgetView
       self._widget._onPortEvent(arguments);
     }
   })({
     frame: iframe,
     contentURL: contentURL,
     contentScriptFile: this._widget.contentScriptFile,
     contentScript: this._widget.contentScript,
     contentScriptWhen: this._widget.contentScriptWhen,
     contentScriptOptions: this._widget.contentScriptOptions,
     allow: this._widget.allow,
     onMessage: function(message) {
       setTimeout(function() {
         self._widget._onEvent("message", message);
       }, 0);
     }
   });
 }
 // Detect if document consists of a single image.
 WidgetChrome._isImageDoc = function WC__isImageDoc(doc) {
   return /*doc.body &&*/ doc.body.childNodes.length == 1 &&
          doc.body.firstElementChild &&
          doc.body.firstElementChild.tagName == "IMG";
 }
 // Set up all supported events for a widget.
 WidgetChrome.prototype.addEventHandlers = function WC_addEventHandlers() {
   let contentType = this.getContentType();
   let self = this;
   let listener = function(e) {
     // Ignore event firings that target the iframe.
     if (e.target == self.node.firstElementChild)
       return;
     // The widget only supports left-click for now,
     // so ignore all clicks (i.e. middle or right) except left ones.
     if (e.type == "click" && e.button !== 0)
       return;
     // Proxy event to the widget
     setTimeout(function() {
       self._widget._onEvent(EVENTS[e.type], null, self.node);
     }, 0);
   };
   this.eventListeners = {};
   let iframe = this.node.firstElementChild;
   for (let type in EVENTS) {
     iframe.addEventListener(type, listener, true, true);
     // Store listeners for later removal
     this.eventListeners[type] = listener;
   }
   // On document load, make modifications required for nice default
   // presentation.
   function loadListener(e) {
     let containerStyle = self.window.getComputedStyle(self.node.parentNode);
     // Ignore event firings that target the iframe
     if (e.target == iframe)
       return;
     // Ignore about:blank loads
     if (e.type == "load" && e.target.location == "about:blank")
       return;
     // We may have had an unload event before that cleaned up the symbiont
     if (!self._symbiont)
       self.setContent();
     let doc = e.target;
     if (contentType == CONTENT_TYPE_IMAGE || WidgetChrome._isImageDoc(doc)) {
       // Force image content to size.
       // Add-on authors must size their images correctly.
       doc.body.firstElementChild.style.width = self._widget.width + "px";
       doc.body.firstElementChild.style.height = "16px";
     }
     // Extend the add-on bar's default text styles to the widget.
     doc.body.style.color = containerStyle.color;
     doc.body.style.fontFamily = containerStyle.fontFamily;
     doc.body.style.fontSize = containerStyle.fontSize;
     doc.body.style.fontWeight = containerStyle.fontWeight;
     doc.body.style.textShadow = containerStyle.textShadow;
     // Allow all content to fill the box by default.
     doc.body.style.margin = "0";
   }
   iframe.addEventListener("load", loadListener, true);
   this.eventListeners["load"] = loadListener;
   // Register a listener to unload symbiont if the toolbaritem is moved
   // on user toolbars customization
   function unloadListener(e) {
     if (e.target.location == "about:blank")
       return;
     self._symbiont.destroy();
     self._symbiont = null;
     // This may fail but not always, it depends on how the node is
     // moved or removed
     try {
       self.setContent();
     } catch(e) {}
   }
   iframe.addEventListener("unload", unloadListener, true);
   this.eventListeners["unload"] = unloadListener;
 }
 // Remove and unregister the widget from everything
 WidgetChrome.prototype.destroy = function WC_destroy(removedItems) {
   // remove event listeners
   for (let type in this.eventListeners) {
     let listener = this.eventListeners[type];
     this.node.firstElementChild.removeEventListener(type, listener, true);
   }
   // remove dom node
   this.node.parentNode.removeChild(this.node);
   // cleanup symbiont
   this._symbiont.destroy();
   // cleanup itself
   this.eventListeners = null;
   this._widget = null;
   this._symbiont = null;
 }
 // Init the browserManager only after setting prototypes and such above, because
 // it will cause browserManager.onTrack to be called immediately if there are
 // open windows.
 browserManager.init();