The Tor Browser / file revision

 # -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 # 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/.

 const Cc = Components.classes;

 const Ci = Components.interfaces;

 const Cr = Components.results;

 const Cu = Components.utils;

 Cu.import("resource://gre/modules/XPCOMUtils.jsm");

 const FEEDWRITER_CID = Components.ID("{49bb6593-3aff-4eb3-a068-2712c28bd58e}");

 const FEEDWRITER_CONTRACTID = "@mozilla.org/browser/feeds/result-writer;1";

 function LOG(str) {

   var prefB = Cc["@mozilla.org/preferences-service;1"].

               getService(Ci.nsIPrefBranch);

   var shouldLog = false;

   try {

     shouldLog = prefB.getBoolPref("feeds.log");

   } 

   catch (ex) {

   }

   if (shouldLog)

     dump("*** Feeds: " + str + "\n");

 }

 /**

  * Wrapper function for nsIIOService::newURI.

  * @param aURLSpec

  *        The URL string from which to create an nsIURI.

  * @returns an nsIURI object, or null if the creation of the URI failed.

  */

 function makeURI(aURLSpec, aCharset) {

   var ios = Cc["@mozilla.org/network/io-service;1"].

             getService(Ci.nsIIOService);

   try {

     return ios.newURI(aURLSpec, aCharset, null);

   } catch (ex) { }

   return null;

 }

 const XML_NS = "http://www.w3.org/XML/1998/namespace";

 const HTML_NS = "http://www.w3.org/1999/xhtml";

 const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";

 const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed";

 const TYPE_MAYBE_AUDIO_FEED = "application/vnd.mozilla.maybe.audio.feed";

 const TYPE_MAYBE_VIDEO_FEED = "application/vnd.mozilla.maybe.video.feed";

 const URI_BUNDLE = "chrome://browser/locale/feeds/subscribe.properties";

 const PREF_SELECTED_APP = "browser.feeds.handlers.application";

 const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice";

 const PREF_SELECTED_ACTION = "browser.feeds.handler";

 const PREF_SELECTED_READER = "browser.feeds.handler.default";

 const PREF_VIDEO_SELECTED_APP = "browser.videoFeeds.handlers.application";

 const PREF_VIDEO_SELECTED_WEB = "browser.videoFeeds.handlers.webservice";

 const PREF_VIDEO_SELECTED_ACTION = "browser.videoFeeds.handler";

 const PREF_VIDEO_SELECTED_READER = "browser.videoFeeds.handler.default";

 const PREF_AUDIO_SELECTED_APP = "browser.audioFeeds.handlers.application";

 const PREF_AUDIO_SELECTED_WEB = "browser.audioFeeds.handlers.webservice";

 const PREF_AUDIO_SELECTED_ACTION = "browser.audioFeeds.handler";

 const PREF_AUDIO_SELECTED_READER = "browser.audioFeeds.handler.default";

 const PREF_SHOW_FIRST_RUN_UI = "browser.feeds.showFirstRunUI";

 const TITLE_ID = "feedTitleText";

 const SUBTITLE_ID = "feedSubtitleText";

 function getPrefAppForType(t) {

   switch (t) {

     case Ci.nsIFeed.TYPE_VIDEO:

       return PREF_VIDEO_SELECTED_APP;

     case Ci.nsIFeed.TYPE_AUDIO:

       return PREF_AUDIO_SELECTED_APP;

     default:

       return PREF_SELECTED_APP;

   }

 }

 function getPrefWebForType(t) {

   switch (t) {

     case Ci.nsIFeed.TYPE_VIDEO:

       return PREF_VIDEO_SELECTED_WEB;

     case Ci.nsIFeed.TYPE_AUDIO:

       return PREF_AUDIO_SELECTED_WEB;

     default:

       return PREF_SELECTED_WEB;

   }

 }

 function getPrefActionForType(t) {

   switch (t) {

     case Ci.nsIFeed.TYPE_VIDEO:

       return PREF_VIDEO_SELECTED_ACTION;

     case Ci.nsIFeed.TYPE_AUDIO:

       return PREF_AUDIO_SELECTED_ACTION;

     default:

       return PREF_SELECTED_ACTION;

   }

 }

 function getPrefReaderForType(t) {

   switch (t) {

     case Ci.nsIFeed.TYPE_VIDEO:

       return PREF_VIDEO_SELECTED_READER;

     case Ci.nsIFeed.TYPE_AUDIO:

       return PREF_AUDIO_SELECTED_READER;

     default:

       return PREF_SELECTED_READER;

   }

 }

 /**

  * Converts a number of bytes to the appropriate unit that results in a

  * number that needs fewer than 4 digits

  *

  * @return a pair: [new value with 3 sig. figs., its unit]

   */

 function convertByteUnits(aBytes) {

   var units = ["bytes", "kilobyte", "megabyte", "gigabyte"];

   let unitIndex = 0;

   // convert to next unit if it needs 4 digits (after rounding), but only if

   // we know the name of the next unit

   while ((aBytes >= 999.5) && (unitIndex < units.length - 1)) {

     aBytes /= 1024;

     unitIndex++;

   }

   // Get rid of insignificant bits by truncating to 1 or 0 decimal points

   // 0 -> 0; 1.2 -> 1.2; 12.3 -> 12.3; 123.4 -> 123; 234.5 -> 235

   aBytes = aBytes.toFixed((aBytes > 0) && (aBytes < 100) ? 1 : 0);

   return [aBytes, units[unitIndex]];

 }

 function FeedWriter() {}

 FeedWriter.prototype = {

   _mimeSvc      : Cc["@mozilla.org/mime;1"].

                   getService(Ci.nsIMIMEService),

   _getPropertyAsBag: function FW__getPropertyAsBag(container, property) {

     return container.fields.getProperty(property).

                      QueryInterface(Ci.nsIPropertyBag2);

   },

   _getPropertyAsString: function FW__getPropertyAsString(container, property) {

     try {

       return container.fields.getPropertyAsAString(property);

     }

     catch (e) {

     }

     return "";

   },

   _setContentText: function FW__setContentText(id, text) {

     this._contentSandbox.element = this._document.getElementById(id);

     this._contentSandbox.textNode = text.createDocumentFragment(this._contentSandbox.element);

     var codeStr =

       "while (element.hasChildNodes()) " +

       "  element.removeChild(element.firstChild);" +

       "element.appendChild(textNode);";

     if (text.base) {

       this._contentSandbox.spec = text.base.spec;

       codeStr += "element.setAttributeNS('" + XML_NS + "', 'base', spec);";

     }

     Cu.evalInSandbox(codeStr, this._contentSandbox);

     this._contentSandbox.element = null;

     this._contentSandbox.textNode = null;

   },

   /**

    * Safely sets the href attribute on an anchor tag, providing the URI 

    * specified can be loaded according to rules. 

    * @param   element

    *          The element to set a URI attribute on

    * @param   attribute

    *          The attribute of the element to set the URI to, e.g. href or src

    * @param   uri

    *          The URI spec to set as the href

    */

   _safeSetURIAttribute: 

   function FW__safeSetURIAttribute(element, attribute, uri) {

     var secman = Cc["@mozilla.org/scriptsecuritymanager;1"].

                  getService(Ci.nsIScriptSecurityManager);    

     const flags = Ci.nsIScriptSecurityManager.DISALLOW_INHERIT_PRINCIPAL;

     try {

       secman.checkLoadURIStrWithPrincipal(this._feedPrincipal, uri, flags);

       // checkLoadURIStrWithPrincipal will throw if the link URI should not be

       // loaded, either because our feedURI isn't allowed to load it or per

       // the rules specified in |flags|, so we'll never "linkify" the link...

     }

     catch (e) {

       // Not allowed to load this link because secman.checkLoadURIStr threw

       return;

     }

     this._contentSandbox.element = element;

     this._contentSandbox.uri = uri;

     var codeStr = "element.setAttribute('" + attribute + "', uri);";

     Cu.evalInSandbox(codeStr, this._contentSandbox);

   },

   /**

    * Use this sandbox to run any dom manipulation code on nodes which

    * are already inserted into the content document.

    */

   __contentSandbox: null,

   get _contentSandbox() {

     // This whole sandbox setup is totally archaic. It was introduced in bug

     // 360529, presumably before the existence of a solid security membrane,

     // since all of the manipulation of content here should be made safe by

     // Xrays. And now that anonymous content is no longer content-accessible,

     // manipulating the xml stylesheet content can't be done from content

     // anymore.

     //

     // The right solution would be to rip out all of this sandbox junk and

     // manipulate the DOM directly. But that's a big yak to shave, so for now,

     // we just give the sandbox an nsExpandedPrincipal with []. This has the

     // effect of giving it Xrays, and making it same-origin with the XBL scope,

     // thereby letting it manipulate anonymous content.

     if (!this.__contentSandbox)

       this.__contentSandbox = new Cu.Sandbox([this._window],

                                              {sandboxName: 'FeedWriter'});

     return this.__contentSandbox;

   },

   /**

    * Calls doCommand for a given XUL element within the context of the

    * content document.

    *

    * @param aElement

    *        the XUL element to call doCommand() on.

    */

   _safeDoCommand: function FW___safeDoCommand(aElement) {

     this._contentSandbox.element = aElement;

     Cu.evalInSandbox("element.doCommand();", this._contentSandbox);

     this._contentSandbox.element = null;

   },

   __faviconService: null,

   get _faviconService() {

     if (!this.__faviconService)

       this.__faviconService = Cc["@mozilla.org/browser/favicon-service;1"].

                               getService(Ci.nsIFaviconService);

     return this.__faviconService;

   },

   __bundle: null,

   get _bundle() {

     if (!this.__bundle) {

       this.__bundle = Cc["@mozilla.org/intl/stringbundle;1"].

                       getService(Ci.nsIStringBundleService).

                       createBundle(URI_BUNDLE);

     }

     return this.__bundle;

   },

   _getFormattedString: function FW__getFormattedString(key, params) {

     return this._bundle.formatStringFromName(key, params, params.length);

   },

   _getString: function FW__getString(key) {

     return this._bundle.GetStringFromName(key);

   },

   /* Magic helper methods to be used instead of xbl properties */

   _getSelectedItemFromMenulist: function FW__getSelectedItemFromList(aList) {

     var node = aList.firstChild.firstChild;

     while (node) {

       if (node.localName == "menuitem" && node.getAttribute("selected") == "true")

         return node;

       node = node.nextSibling;

     }

     return null;

   },

   _setCheckboxCheckedState: function FW__setCheckboxCheckedState(aCheckbox, aValue) {

     // see checkbox.xml, xbl bindings are not applied within the sandbox!

     this._contentSandbox.checkbox = aCheckbox;

     var codeStr;

     var change = (aValue != (aCheckbox.getAttribute('checked') == 'true'));

     if (aValue)

       codeStr = "checkbox.setAttribute('checked', 'true'); ";

     else

       codeStr = "checkbox.removeAttribute('checked'); ";

     if (change) {

       this._contentSandbox.document = this._document;

       codeStr += "var event = document.createEvent('Events'); " +

                  "event.initEvent('CheckboxStateChange', true, true);" +

                  "checkbox.dispatchEvent(event);"

     }

     Cu.evalInSandbox(codeStr, this._contentSandbox);

   },

    /**

    * Returns a date suitable for displaying in the feed preview. 

    * If the date cannot be parsed, the return value is "false".

    * @param   dateString

    *          A date as extracted from a feed entry. (entry.updated)

    */

   _parseDate: function FW__parseDate(dateString) {

     // Convert the date into the user's local time zone

     dateObj = new Date(dateString);

     // Make sure the date we're given is valid.

     if (!dateObj.getTime())

       return false;

     var dateService = Cc["@mozilla.org/intl/scriptabledateformat;1"].

                       getService(Ci.nsIScriptableDateFormat);

     return dateService.FormatDateTime("", dateService.dateFormatLong, dateService.timeFormatNoSeconds,

                                       dateObj.getFullYear(), dateObj.getMonth()+1, dateObj.getDate(),

                                       dateObj.getHours(), dateObj.getMinutes(), dateObj.getSeconds());

   },

   /**

    * Returns the feed type.

    */

   __feedType: null,

   _getFeedType: function FW__getFeedType() {

     if (this.__feedType != null)

       return this.__feedType;

     try {

       // grab the feed because it's got the feed.type in it.

       var container = this._getContainer();

       var feed = container.QueryInterface(Ci.nsIFeed);

       this.__feedType = feed.type;

       return feed.type;

     } catch (ex) { }

     return Ci.nsIFeed.TYPE_FEED;

   },

   /**

    * Maps a feed type to a maybe-feed mimetype.

    */

   _getMimeTypeForFeedType: function FW__getMimeTypeForFeedType() {

     switch (this._getFeedType()) {

       case Ci.nsIFeed.TYPE_VIDEO:

         return TYPE_MAYBE_VIDEO_FEED;

       case Ci.nsIFeed.TYPE_AUDIO:

         return TYPE_MAYBE_AUDIO_FEED;

       default:

         return TYPE_MAYBE_FEED;

     }

   },

   /**

    * Writes the feed title into the preview document.

    * @param   container

    *          The feed container

    */

   _setTitleText: function FW__setTitleText(container) {

     if (container.title) {

       var title = container.title.plainText();

       this._setContentText(TITLE_ID, container.title);

       this._contentSandbox.document = this._document;

       this._contentSandbox.title = title;

       var codeStr = "document.title = title;"

       Cu.evalInSandbox(codeStr, this._contentSandbox);

     }

     var feed = container.QueryInterface(Ci.nsIFeed);

     if (feed && feed.subtitle)

       this._setContentText(SUBTITLE_ID, container.subtitle);

   },

   /**

    * Writes the title image into the preview document if one is present.

    * @param   container

    *          The feed container

    */

   _setTitleImage: function FW__setTitleImage(container) {

     try {

       var parts = container.image;

       // Set up the title image (supplied by the feed)

       var feedTitleImage = this._document.getElementById("feedTitleImage");

       this._safeSetURIAttribute(feedTitleImage, "src", 

                                 parts.getPropertyAsAString("url"));

       // Set up the title image link

       var feedTitleLink = this._document.getElementById("feedTitleLink");

       var titleText = this._getFormattedString("linkTitleTextFormat", 

                                                [parts.getPropertyAsAString("title")]);

       this._contentSandbox.feedTitleLink = feedTitleLink;

       this._contentSandbox.titleText = titleText;

       this._contentSandbox.feedTitleText = this._document.getElementById("feedTitleText");

       this._contentSandbox.titleImageWidth = parseInt(parts.getPropertyAsAString("width")) + 15;

       // Fix the margin on the main title, so that the image doesn't run over

       // the underline

       var codeStr = "feedTitleLink.setAttribute('title', titleText); " +

                     "feedTitleText.style.marginRight = titleImageWidth + 'px';";

       Cu.evalInSandbox(codeStr, this._contentSandbox);

       this._contentSandbox.feedTitleLink = null;

       this._contentSandbox.titleText = null;

       this._contentSandbox.feedTitleText = null;

       this._contentSandbox.titleImageWidth = null;

       this._safeSetURIAttribute(feedTitleLink, "href", 

                                 parts.getPropertyAsAString("link"));

     }

     catch (e) {

       LOG("Failed to set Title Image (this is benign): " + e);

     }

   },

   /**

    * Writes all entries contained in the feed.

    * @param   container

    *          The container of entries in the feed

    */

   _writeFeedContent: function FW__writeFeedContent(container) {

     // Build the actual feed content

     var feed = container.QueryInterface(Ci.nsIFeed);

     if (feed.items.length == 0)

       return;

     this._contentSandbox.feedContent =

       this._document.getElementById("feedContent");

     for (var i = 0; i < feed.items.length; ++i) {

       var entry = feed.items.queryElementAt(i, Ci.nsIFeedEntry);

       entry.QueryInterface(Ci.nsIFeedContainer);

       var entryContainer = this._document.createElementNS(HTML_NS, "div");

       entryContainer.className = "entry";

       // If the entry has a title, make it a link

       if (entry.title) {

         var a = this._document.createElementNS(HTML_NS, "a");

         var span = this._document.createElementNS(HTML_NS, "span");

         a.appendChild(span);

         if (entry.title.base)

           span.setAttributeNS(XML_NS, "base", entry.title.base.spec);

         span.appendChild(entry.title.createDocumentFragment(a));

         // Entries are not required to have links, so entry.link can be null.

         if (entry.link)

           this._safeSetURIAttribute(a, "href", entry.link.spec);

         var title = this._document.createElementNS(HTML_NS, "h3");

         title.appendChild(a);

         var lastUpdated = this._parseDate(entry.updated);

         if (lastUpdated) {

           var dateDiv = this._document.createElementNS(HTML_NS, "div");

           dateDiv.className = "lastUpdated";

           dateDiv.textContent = lastUpdated;

           title.appendChild(dateDiv);

         }

         entryContainer.appendChild(title);

       }

       var body = this._document.createElementNS(HTML_NS, "div");

       var summary = entry.summary || entry.content;

       var docFragment = null;

       if (summary) {

         if (summary.base)

           body.setAttributeNS(XML_NS, "base", summary.base.spec);

         else

           LOG("no base?");

         docFragment = summary.createDocumentFragment(body);

         if (docFragment)

           body.appendChild(docFragment);

         // If the entry doesn't have a title, append a # permalink

         // See http://scripting.com/rss.xml for an example

         if (!entry.title && entry.link) {

           var a = this._document.createElementNS(HTML_NS, "a");

           a.appendChild(this._document.createTextNode("#"));

           this._safeSetURIAttribute(a, "href", entry.link.spec);

           body.appendChild(this._document.createTextNode(" "));

           body.appendChild(a);

         }

       }

       body.className = "feedEntryContent";

       entryContainer.appendChild(body);

       if (entry.enclosures && entry.enclosures.length > 0) {

         var enclosuresDiv = this._buildEnclosureDiv(entry);

         entryContainer.appendChild(enclosuresDiv);

       }

       this._contentSandbox.entryContainer = entryContainer;

       this._contentSandbox.clearDiv =

         this._document.createElementNS(HTML_NS, "div");

       this._contentSandbox.clearDiv.style.clear = "both";

       var codeStr = "feedContent.appendChild(entryContainer); " +

                      "feedContent.appendChild(clearDiv);"

       Cu.evalInSandbox(codeStr, this._contentSandbox);

     }

     this._contentSandbox.feedContent = null;

     this._contentSandbox.entryContainer = null;

     this._contentSandbox.clearDiv = null;

   },

   /**

    * Takes a url to a media item and returns the best name it can come up with.

    * Frequently this is the filename portion (e.g. passing in 

    * http://example.com/foo.mpeg would return "foo.mpeg"), but in more complex

    * cases, this will return the entire url (e.g. passing in

    * http://example.com/somedirectory/ would return 

    * http://example.com/somedirectory/).

    * @param aURL

    *        The URL string from which to create a display name

    * @returns a string

    */

   _getURLDisplayName: function FW__getURLDisplayName(aURL) {

     var url = makeURI(aURL);

     url.QueryInterface(Ci.nsIURL);

     if (url == null || url.fileName.length == 0)

       return decodeURIComponent(aURL);

     return decodeURIComponent(url.fileName);

   },

   /**

    * Takes a FeedEntry with enclosures, generates the HTML code to represent

    * them, and returns that.

    * @param   entry

    *          FeedEntry with enclosures

    * @returns element

    */

   _buildEnclosureDiv: function FW__buildEnclosureDiv(entry) {

     var enclosuresDiv = this._document.createElementNS(HTML_NS, "div");

     enclosuresDiv.className = "enclosures";

     enclosuresDiv.appendChild(this._document.createTextNode(this._getString("mediaLabel")));

     var roundme = function(n) {

       return (Math.round(n * 100) / 100).toLocaleString();

     }

     for (var i_enc = 0; i_enc < entry.enclosures.length; ++i_enc) {

       var enc = entry.enclosures.queryElementAt(i_enc, Ci.nsIWritablePropertyBag2);

       if (!(enc.hasKey("url"))) 

         continue;

       var enclosureDiv = this._document.createElementNS(HTML_NS, "div");

       enclosureDiv.setAttribute("class", "enclosure");

       var mozicon = "moz-icon://.txt?size=16";

       var type_text = null;

       var size_text = null;

       if (enc.hasKey("type")) {

         type_text = enc.get("type");

         try {

           var handlerInfoWrapper = this._mimeSvc.getFromTypeAndExtension(enc.get("type"), null);

           if (handlerInfoWrapper)

             type_text = handlerInfoWrapper.description;

           if  (type_text && type_text.length > 0)

             mozicon = "moz-icon://goat?size=16&contentType=" + enc.get("type");

         } catch (ex) { }

       }

       if (enc.hasKey("length") && /^[0-9]+$/.test(enc.get("length"))) {

         var enc_size = convertByteUnits(parseInt(enc.get("length")));

         var size_text = this._getFormattedString("enclosureSizeText", 

                              [enc_size[0], this._getString(enc_size[1])]);

       }

       var iconimg = this._document.createElementNS(HTML_NS, "img");

       iconimg.setAttribute("src", mozicon);

       iconimg.setAttribute("class", "type-icon");

       enclosureDiv.appendChild(iconimg);

       enclosureDiv.appendChild(this._document.createTextNode( " " ));

       var enc_href = this._document.createElementNS(HTML_NS, "a");

       enc_href.appendChild(this._document.createTextNode(this._getURLDisplayName(enc.get("url"))));

       this._safeSetURIAttribute(enc_href, "href", enc.get("url"));

       enclosureDiv.appendChild(enc_href);

       if (type_text && size_text)

         enclosureDiv.appendChild(this._document.createTextNode( " (" + type_text + ", " + size_text + ")"));

       else if (type_text) 

         enclosureDiv.appendChild(this._document.createTextNode( " (" + type_text + ")"))

       else if (size_text)

         enclosureDiv.appendChild(this._document.createTextNode( " (" + size_text + ")"))

       enclosuresDiv.appendChild(enclosureDiv);

     }

     return enclosuresDiv;

   },

   /**

    * Gets a valid nsIFeedContainer object from the parsed nsIFeedResult.

    * Displays error information if there was one.

    * @param   result

    *          The parsed feed result

    * @returns A valid nsIFeedContainer object containing the contents of

    *          the feed.

    */

   _getContainer: function FW__getContainer(result) {

     var feedService = 

         Cc["@mozilla.org/browser/feeds/result-service;1"].

         getService(Ci.nsIFeedResultService);

     try {

       var result = 

         feedService.getFeedResult(this._getOriginalURI(this._window));

     }

     catch (e) {

       LOG("Subscribe Preview: feed not available?!");

     }

     if (result.bozo) {

       LOG("Subscribe Preview: feed result is bozo?!");

     }

     try {

       var container = result.doc;

     }

     catch (e) {

       LOG("Subscribe Preview: no result.doc? Why didn't the original reload?");

       return null;

     }

     return container;

   },

   /**

    * Get the human-readable display name of a file. This could be the 

    * application name.

    * @param   file

    *          A nsIFile to look up the name of

    * @returns The display name of the application represented by the file.

    */

   _getFileDisplayName: function FW__getFileDisplayName(file) {

 #ifdef XP_WIN

     if (file instanceof Ci.nsILocalFileWin) {

       try {

         return file.getVersionInfoField("FileDescription");

       } catch (e) {}

     }

 #endif

 #ifdef XP_MACOSX

     if (file instanceof Ci.nsILocalFileMac) {

       try {

         return file.bundleDisplayName;

       } catch (e) {}

     }

 #endif

     return file.leafName;

   },

   /**

    * Get moz-icon url for a file

    * @param   file

    *          A nsIFile object for which the moz-icon:// is returned

    * @returns moz-icon url of the given file as a string

    */

   _getFileIconURL: function FW__getFileIconURL(file) {

     var ios = Cc["@mozilla.org/network/io-service;1"].

               getService(Ci.nsIIOService);

     var fph = ios.getProtocolHandler("file")

                  .QueryInterface(Ci.nsIFileProtocolHandler);

     var urlSpec = fph.getURLSpecFromFile(file);

     return "moz-icon://" + urlSpec + "?size=16";

   },

   /**

    * Helper method to set the selected application and system default

    * reader menuitems details from a file object

    *   @param aMenuItem

    *          The menuitem on which the attributes should be set

    *   @param aFile

    *          The menuitem's associated file

    */

   _initMenuItemWithFile: function(aMenuItem, aFile) {

     this._contentSandbox.menuitem = aMenuItem;

     this._contentSandbox.label = this._getFileDisplayName(aFile);

     this._contentSandbox.image = this._getFileIconURL(aFile);

     var codeStr = "menuitem.setAttribute('label', label); " +

                   "menuitem.setAttribute('image', image);"

     Cu.evalInSandbox(codeStr, this._contentSandbox);

   },

   /**

    * Helper method to get an element in the XBL binding where the handler

    * selection UI lives

    */

   _getUIElement: function FW__getUIElement(id) {

     return this._document.getAnonymousElementByAttribute(

       this._document.getElementById("feedSubscribeLine"), "anonid", id);

   },

   /**

    * Displays a prompt from which the user may choose a (client) feed reader.

    * @param aCallback the callback method, passes in true if a feed reader was

    *        selected, false otherwise.

    */

   _chooseClientApp: function FW__chooseClientApp(aCallback) {

     try {

       let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);

       let fpCallback = function fpCallback_done(aResult) {

         if (aResult == Ci.nsIFilePicker.returnOK) {

           this._selectedApp = fp.file;

           if (this._selectedApp) {

             // XXXben - we need to compare this with the running instance

             //          executable just don't know how to do that via script

             // XXXmano TBD: can probably add this to nsIShellService

 #ifdef XP_WIN

 #expand             if (fp.file.leafName != "__MOZ_APP_NAME__.exe") {

 #else

 #ifdef XP_MACOSX

 #expand             if (fp.file.leafName != "__MOZ_MACBUNDLE_NAME__") {

 #else

 #expand             if (fp.file.leafName != "__MOZ_APP_NAME__-bin") {

 #endif

 #endif

               this._initMenuItemWithFile(this._contentSandbox.selectedAppMenuItem,

                                          this._selectedApp);

               // Show and select the selected application menuitem

               let codeStr = "selectedAppMenuItem.hidden = false;" +

                             "selectedAppMenuItem.doCommand();"

               Cu.evalInSandbox(codeStr, this._contentSandbox);

               if (aCallback) {

                 aCallback(true);

                 return;

               }

             }

           }

         }

         if (aCallback) {

           aCallback(false);

         }

       }.bind(this);

       fp.init(this._window, this._getString("chooseApplicationDialogTitle"),

               Ci.nsIFilePicker.modeOpen);

       fp.appendFilters(Ci.nsIFilePicker.filterApps);

       fp.open(fpCallback);

     } catch(ex) {

     }

   },

   _setAlwaysUseCheckedState: function FW__setAlwaysUseCheckedState(feedType) {

     var checkbox = this._getUIElement("alwaysUse");

     if (checkbox) {

       var alwaysUse = false;

       try {

         var prefs = Cc["@mozilla.org/preferences-service;1"].

                     getService(Ci.nsIPrefBranch);

         if (prefs.getCharPref(getPrefActionForType(feedType)) != "ask")

           alwaysUse = true;

       }

       catch(ex) { }

       this._setCheckboxCheckedState(checkbox, alwaysUse);

     }

   },

   _setSubscribeUsingLabel: function FW__setSubscribeUsingLabel() {

     var stringLabel = "subscribeFeedUsing";

     switch (this._getFeedType()) {

       case Ci.nsIFeed.TYPE_VIDEO:

         stringLabel = "subscribeVideoPodcastUsing";

         break;

       case Ci.nsIFeed.TYPE_AUDIO:

         stringLabel = "subscribeAudioPodcastUsing";

         break;

     }

     this._contentSandbox.subscribeUsing =

       this._getUIElement("subscribeUsingDescription");

     this._contentSandbox.label = this._getString(stringLabel);

     var codeStr = "subscribeUsing.setAttribute('value', label);"

     Cu.evalInSandbox(codeStr, this._contentSandbox);

   },

   _setAlwaysUseLabel: function FW__setAlwaysUseLabel() {

     var checkbox = this._getUIElement("alwaysUse");

     if (checkbox) {

       if (this._handlersMenuList) {

         var handlerName = this._getSelectedItemFromMenulist(this._handlersMenuList)

                               .getAttribute("label");

         var stringLabel = "alwaysUseForFeeds";

         switch (this._getFeedType()) {

           case Ci.nsIFeed.TYPE_VIDEO:

             stringLabel = "alwaysUseForVideoPodcasts";

             break;

           case Ci.nsIFeed.TYPE_AUDIO:

             stringLabel = "alwaysUseForAudioPodcasts";

             break;

         }

         this._contentSandbox.checkbox = checkbox;

         this._contentSandbox.label = this._getFormattedString(stringLabel, [handlerName]);

         var codeStr = "checkbox.setAttribute('label', label);";

         Cu.evalInSandbox(codeStr, this._contentSandbox);

       }

     }

   },

   // nsIDomEventListener

   handleEvent: function(event) {

     if (event.target.ownerDocument != this._document) {

       LOG("FeedWriter.handleEvent: Someone passed the feed writer as a listener to the events of another document!");

       return;

     }

     if (event.type == "command") {

       switch (event.target.getAttribute("anonid")) {

         case "subscribeButton":

           this.subscribe();

           break;

         case "chooseApplicationMenuItem":

           /* Bug 351263: Make sure to not steal focus if the "Choose

            * Application" item is being selected with the keyboard. We do this

            * by ignoring command events while the dropdown is closed (user

            * arrowing through the combobox), but handling them while the

            * combobox dropdown is open (user pressed enter when an item was

            * selected). If we don't show the filepicker here, it will be shown

            * when clicking "Subscribe Now".

            */

           var popupbox = this._handlersMenuList.firstChild.boxObject;

           popupbox.QueryInterface(Components.interfaces.nsIPopupBoxObject);

           if (popupbox.popupState == "hiding") {

             this._chooseClientApp(function(aResult) {

               if (!aResult) {

                 // Select the (per-prefs) selected handler if no application

                 // was selected

                 this._setSelectedHandler(this._getFeedType());

               }

             }.bind(this));

           }

           break;

         default:

           this._setAlwaysUseLabel();

       }

     }

   },

   _setSelectedHandler: function FW__setSelectedHandler(feedType) {

     var prefs =   

         Cc["@mozilla.org/preferences-service;1"].

         getService(Ci.nsIPrefBranch);

     var handler = "bookmarks";

     try {

       handler = prefs.getCharPref(getPrefReaderForType(feedType));

     }

     catch (ex) { }

     switch (handler) {

       case "web": {

         if (this._handlersMenuList) {

           var url = prefs.getComplexValue(getPrefWebForType(feedType), Ci.nsISupportsString).data;

           var handlers =

             this._handlersMenuList.getElementsByAttribute("webhandlerurl", url);

           if (handlers.length == 0) {

             LOG("FeedWriter._setSelectedHandler: selected web handler isn't in the menulist")

             return;

           }

           this._safeDoCommand(handlers[0]);

         }

         break;

       }

       case "client": {

         try {

           this._selectedApp =

             prefs.getComplexValue(getPrefAppForType(feedType), Ci.nsILocalFile);

         }

         catch(ex) {

           this._selectedApp = null;

         }

         if (this._selectedApp) {

           this._initMenuItemWithFile(this._contentSandbox.selectedAppMenuItem,

                                      this._selectedApp);

           var codeStr = "selectedAppMenuItem.hidden = false; " +

                         "selectedAppMenuItem.doCommand(); ";

           // Only show the default reader menuitem if the default reader

           // isn't the selected application

           if (this._defaultSystemReader) {

             var shouldHide =

               this._defaultSystemReader.path == this._selectedApp.path;

             codeStr += "defaultHandlerMenuItem.hidden = " + shouldHide + ";"

           }

           Cu.evalInSandbox(codeStr, this._contentSandbox);

           break;

         }

       }

       case "bookmarks":

       default: {

         var liveBookmarksMenuItem = this._getUIElement("liveBookmarksMenuItem");

         if (liveBookmarksMenuItem)

           this._safeDoCommand(liveBookmarksMenuItem);

       } 

     }

   },

   _initSubscriptionUI: function FW__initSubscriptionUI() {

     var handlersMenuPopup = this._getUIElement("handlersMenuPopup");

     if (!handlersMenuPopup)

       return;

     var feedType = this._getFeedType();

     var codeStr;

     // change the background

     var header = this._document.getElementById("feedHeader");

     this._contentSandbox.header = header;

     switch (feedType) {

       case Ci.nsIFeed.TYPE_VIDEO:

         codeStr = "header.className = 'videoPodcastBackground'; ";

         break;

       case Ci.nsIFeed.TYPE_AUDIO:

         codeStr = "header.className = 'audioPodcastBackground'; ";

         break;

       default:

         codeStr = "header.className = 'feedBackground'; ";

     }

     var liveBookmarksMenuItem = this._getUIElement("liveBookmarksMenuItem");

     // Last-selected application

     var menuItem = liveBookmarksMenuItem.cloneNode(false);

     menuItem.removeAttribute("selected");

     menuItem.setAttribute("anonid", "selectedAppMenuItem");

     menuItem.className = "menuitem-iconic selectedAppMenuItem";

     menuItem.setAttribute("handlerType", "client");

     try {

       var prefs = Cc["@mozilla.org/preferences-service;1"].

                   getService(Ci.nsIPrefBranch);

       this._selectedApp = prefs.getComplexValue(getPrefAppForType(feedType),

                                                 Ci.nsILocalFile);

       if (this._selectedApp.exists())

         this._initMenuItemWithFile(menuItem, this._selectedApp);

       else {

         // Hide the menuitem if the last selected application doesn't exist

         menuItem.setAttribute("hidden", true);

       }

     }

     catch(ex) {

       // Hide the menuitem until an application is selected

       menuItem.setAttribute("hidden", true);

     }

     this._contentSandbox.handlersMenuPopup = handlersMenuPopup;

     this._contentSandbox.selectedAppMenuItem = menuItem;

     codeStr += "handlersMenuPopup.appendChild(selectedAppMenuItem); ";

     // List the default feed reader

     try {

       this._defaultSystemReader = Cc["@mozilla.org/browser/shell-service;1"].

                                   getService(Ci.nsIShellService).

                                   defaultFeedReader;

       menuItem = liveBookmarksMenuItem.cloneNode(false);

       menuItem.removeAttribute("selected");

       menuItem.setAttribute("anonid", "defaultHandlerMenuItem");

       menuItem.className = "menuitem-iconic defaultHandlerMenuItem";

       menuItem.setAttribute("handlerType", "client");

       this._initMenuItemWithFile(menuItem, this._defaultSystemReader);

       // Hide the default reader item if it points to the same application

       // as the last-selected application

       if (this._selectedApp &&

           this._selectedApp.path == this._defaultSystemReader.path)

         menuItem.hidden = true;

     }

     catch(ex) { menuItem = null; /* no default reader */ }

     if (menuItem) {

       this._contentSandbox.defaultHandlerMenuItem = menuItem;

       codeStr += "handlersMenuPopup.appendChild(defaultHandlerMenuItem); ";

     }

     // "Choose Application..." menuitem

     menuItem = liveBookmarksMenuItem.cloneNode(false);

     menuItem.removeAttribute("selected");

     menuItem.setAttribute("anonid", "chooseApplicationMenuItem");

     menuItem.className = "menuitem-iconic chooseApplicationMenuItem";

     menuItem.setAttribute("label", this._getString("chooseApplicationMenuItem"));

     this._contentSandbox.chooseAppMenuItem = menuItem;

     codeStr += "handlersMenuPopup.appendChild(chooseAppMenuItem); ";

     // separator

     this._contentSandbox.chooseAppSep =

       menuItem = liveBookmarksMenuItem.nextSibling.cloneNode(false);

     codeStr += "handlersMenuPopup.appendChild(chooseAppSep); ";

     Cu.evalInSandbox(codeStr, this._contentSandbox);

     // List of web handlers

     var wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].

                getService(Ci.nsIWebContentConverterService);

     var handlers = wccr.getContentHandlers(this._getMimeTypeForFeedType(feedType));

     if (handlers.length != 0) {

       for (var i = 0; i < handlers.length; ++i) {

         menuItem = liveBookmarksMenuItem.cloneNode(false);

         menuItem.removeAttribute("selected");

         menuItem.className = "menuitem-iconic";

         menuItem.setAttribute("label", handlers[i].name);

         menuItem.setAttribute("handlerType", "web");

         menuItem.setAttribute("webhandlerurl", handlers[i].uri);

         this._contentSandbox.menuItem = menuItem;

         codeStr = "handlersMenuPopup.appendChild(menuItem);";

         Cu.evalInSandbox(codeStr, this._contentSandbox);

         this._setFaviconForWebReader(handlers[i].uri, menuItem);

       }

       this._contentSandbox.menuItem = null;

     }

     this._setSelectedHandler(feedType);

     // "Subscribe using..."

     this._setSubscribeUsingLabel();

     // "Always use..." checkbox initial state

     this._setAlwaysUseCheckedState(feedType);

     this._setAlwaysUseLabel();

     // We update the "Always use.." checkbox label whenever the selected item

     // in the list is changed

     handlersMenuPopup.addEventListener("command", this, false);

     // Set up the "Subscribe Now" button

     this._getUIElement("subscribeButton")

         .addEventListener("command", this, false);

     // first-run ui

     var showFirstRunUI = true;

     try {

       showFirstRunUI = prefs.getBoolPref(PREF_SHOW_FIRST_RUN_UI);

     }

     catch (ex) { }

     if (showFirstRunUI) {

       var textfeedinfo1, textfeedinfo2;

       switch (feedType) {

         case Ci.nsIFeed.TYPE_VIDEO:

           textfeedinfo1 = "feedSubscriptionVideoPodcast1";

           textfeedinfo2 = "feedSubscriptionVideoPodcast2";

           break;

         case Ci.nsIFeed.TYPE_AUDIO:

           textfeedinfo1 = "feedSubscriptionAudioPodcast1";

           textfeedinfo2 = "feedSubscriptionAudioPodcast2";

           break;

         default:

           textfeedinfo1 = "feedSubscriptionFeed1";

           textfeedinfo2 = "feedSubscriptionFeed2";

       }

       this._contentSandbox.feedinfo1 =

         this._document.getElementById("feedSubscriptionInfo1");

       this._contentSandbox.feedinfo1Str = this._getString(textfeedinfo1);

       this._contentSandbox.feedinfo2 =

         this._document.getElementById("feedSubscriptionInfo2");

       this._contentSandbox.feedinfo2Str = this._getString(textfeedinfo2);

       this._contentSandbox.header = header;

       codeStr = "feedinfo1.textContent = feedinfo1Str; " +

                 "feedinfo2.textContent = feedinfo2Str; " +

                 "header.setAttribute('firstrun', 'true');"

       Cu.evalInSandbox(codeStr, this._contentSandbox);

       prefs.setBoolPref(PREF_SHOW_FIRST_RUN_UI, false);

     }

   },

   /**

    * Returns the original URI object of the feed and ensures that this

    * component is only ever invoked from the preview document.  

    * @param aWindow 

    *        The window of the document invoking the BrowserFeedWriter

    */

   _getOriginalURI: function FW__getOriginalURI(aWindow) {

     var chan = aWindow.QueryInterface(Ci.nsIInterfaceRequestor).

                getInterface(Ci.nsIWebNavigation).

                QueryInterface(Ci.nsIDocShell).currentDocumentChannel;

     var resolvedURI = Cc["@mozilla.org/network/io-service;1"].

                       getService(Ci.nsIIOService).

                       newChannel("about:feeds", null, null).URI;

     if (resolvedURI.equals(chan.URI))

       return chan.originalURI;

     return null;

   },

   _window: null,

   _document: null,

   _feedURI: null,

   _feedPrincipal: null,

   _handlersMenuList: null,

   // BrowserFeedWriter WebIDL methods

   init: function FW_init(aWindow) {

     var window = aWindow;

     this._feedURI = this._getOriginalURI(window);

     if (!this._feedURI)

       return;

     this._window = window;

     this._document = window.document;

     this._document.getElementById("feedSubscribeLine").offsetTop;

     this._handlersMenuList = this._getUIElement("handlersMenuList");

     var secman = Cc["@mozilla.org/scriptsecuritymanager;1"].

                  getService(Ci.nsIScriptSecurityManager);

     this._feedPrincipal = secman.getSimpleCodebasePrincipal(this._feedURI);

     LOG("Subscribe Preview: feed uri = " + this._window.location.href);

     // Set up the subscription UI

     this._initSubscriptionUI();

     var prefs = Cc["@mozilla.org/preferences-service;1"].

                 getService(Ci.nsIPrefBranch);

     prefs.addObserver(PREF_SELECTED_ACTION, this, false);

     prefs.addObserver(PREF_SELECTED_READER, this, false);

     prefs.addObserver(PREF_SELECTED_WEB, this, false);

     prefs.addObserver(PREF_SELECTED_APP, this, false);

     prefs.addObserver(PREF_VIDEO_SELECTED_ACTION, this, false);

     prefs.addObserver(PREF_VIDEO_SELECTED_READER, this, false);

     prefs.addObserver(PREF_VIDEO_SELECTED_WEB, this, false);

     prefs.addObserver(PREF_VIDEO_SELECTED_APP, this, false);

     prefs.addObserver(PREF_AUDIO_SELECTED_ACTION, this, false);

     prefs.addObserver(PREF_AUDIO_SELECTED_READER, this, false);

     prefs.addObserver(PREF_AUDIO_SELECTED_WEB, this, false);

     prefs.addObserver(PREF_AUDIO_SELECTED_APP, this, false);

   },

   writeContent: function FW_writeContent() {

     if (!this._window)

       return;

     try {

       // Set up the feed content

       var container = this._getContainer();

       if (!container)

         return;

       this._setTitleText(container);

       this._setTitleImage(container);

       this._writeFeedContent(container);

     }

     finally {

       this._removeFeedFromCache();

     }

   },

   close: function FW_close() {

     this._getUIElement("handlersMenuPopup")

         .removeEventListener("command", this, false);

     this._getUIElement("subscribeButton")

         .removeEventListener("command", this, false);

     this._document = null;

     this._window = null;

     var prefs = Cc["@mozilla.org/preferences-service;1"].

                 getService(Ci.nsIPrefBranch);

     prefs.removeObserver(PREF_SELECTED_ACTION, this);

     prefs.removeObserver(PREF_SELECTED_READER, this);

     prefs.removeObserver(PREF_SELECTED_WEB, this);

     prefs.removeObserver(PREF_SELECTED_APP, this);

     prefs.removeObserver(PREF_VIDEO_SELECTED_ACTION, this);

     prefs.removeObserver(PREF_VIDEO_SELECTED_READER, this);

     prefs.removeObserver(PREF_VIDEO_SELECTED_WEB, this);

     prefs.removeObserver(PREF_VIDEO_SELECTED_APP, this);

     prefs.removeObserver(PREF_AUDIO_SELECTED_ACTION, this);

     prefs.removeObserver(PREF_AUDIO_SELECTED_READER, this);

     prefs.removeObserver(PREF_AUDIO_SELECTED_WEB, this);

     prefs.removeObserver(PREF_AUDIO_SELECTED_APP, this);

     this._removeFeedFromCache();

     this.__faviconService = null;

     this.__bundle = null;

     this._feedURI = null;

     this.__contentSandbox = null;

   },

   _removeFeedFromCache: function FW__removeFeedFromCache() {

     if (this._feedURI) {

       var feedService = Cc["@mozilla.org/browser/feeds/result-service;1"].

                         getService(Ci.nsIFeedResultService);

       feedService.removeFeedResult(this._feedURI);

       this._feedURI = null;

     }

   },

   subscribe: function FW_subscribe() {

     var feedType = this._getFeedType();

     // Subscribe to the feed using the selected handler and save prefs

     var prefs = Cc["@mozilla.org/preferences-service;1"].

                 getService(Ci.nsIPrefBranch);

     var defaultHandler = "reader";

     var useAsDefault = this._getUIElement("alwaysUse").getAttribute("checked");

     var selectedItem = this._getSelectedItemFromMenulist(this._handlersMenuList);

     let subscribeCallback = function() {

       if (selectedItem.hasAttribute("webhandlerurl")) {

         var webURI = selectedItem.getAttribute("webhandlerurl");

         prefs.setCharPref(getPrefReaderForType(feedType), "web");

         var supportsString = Cc["@mozilla.org/supports-string;1"].

                              createInstance(Ci.nsISupportsString);

         supportsString.data = webURI;

         prefs.setComplexValue(getPrefWebForType(feedType), Ci.nsISupportsString,

                               supportsString);

         var wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].

                    getService(Ci.nsIWebContentConverterService);

         var handler = wccr.getWebContentHandlerByURI(this._getMimeTypeForFeedType(feedType), webURI);

         if (handler) {

           if (useAsDefault) {

             wccr.setAutoHandler(this._getMimeTypeForFeedType(feedType), handler);

           }

           this._window.location.href = handler.getHandlerURI(this._window.location.href);

         }

       } else {

         switch (selectedItem.getAttribute("anonid")) {

           case "selectedAppMenuItem":

             prefs.setComplexValue(getPrefAppForType(feedType), Ci.nsILocalFile, 

                                   this._selectedApp);

             prefs.setCharPref(getPrefReaderForType(feedType), "client");

             break;

           case "defaultHandlerMenuItem":

             prefs.setComplexValue(getPrefAppForType(feedType), Ci.nsILocalFile, 

                                   this._defaultSystemReader);

             prefs.setCharPref(getPrefReaderForType(feedType), "client");

             break;

           case "liveBookmarksMenuItem":

             defaultHandler = "bookmarks";

             prefs.setCharPref(getPrefReaderForType(feedType), "bookmarks");

             break;

         }

         var feedService = Cc["@mozilla.org/browser/feeds/result-service;1"].

                           getService(Ci.nsIFeedResultService);

         // Pull the title and subtitle out of the document

         var feedTitle = this._document.getElementById(TITLE_ID).textContent;

         var feedSubtitle = this._document.getElementById(SUBTITLE_ID).textContent;

         feedService.addToClientReader(this._window.location.href, feedTitle, feedSubtitle, feedType);

       }

       // If "Always use..." is checked, we should set PREF_*SELECTED_ACTION

       // to either "reader" (If a web reader or if an application is selected),

       // or to "bookmarks" (if the live bookmarks option is selected).

       // Otherwise, we should set it to "ask"

       if (useAsDefault) {

         prefs.setCharPref(getPrefActionForType(feedType), defaultHandler);

       } else {

         prefs.setCharPref(getPrefActionForType(feedType), "ask");

       }

     }.bind(this);

     // Show the file picker before subscribing if the

     // choose application menuitem was chosen using the keyboard

     if (selectedItem.getAttribute("anonid") == "chooseApplicationMenuItem") {

       this._chooseClientApp(function(aResult) {

         if (aResult) {

           selectedItem =

             this._getSelectedItemFromMenulist(this._handlersMenuList);

           subscribeCallback();

         }

       }.bind(this));

     } else {

       subscribeCallback();

     }

   },

   // nsIObserver

   observe: function FW_observe(subject, topic, data) {

     if (!this._window) {

       // this._window is null unless this.init was called with a trusted

       // window object.

       return;

     }

     var feedType = this._getFeedType();

     if (topic == "nsPref:changed") {

       switch (data) {

         case PREF_SELECTED_READER:

         case PREF_SELECTED_WEB:

         case PREF_SELECTED_APP:

         case PREF_VIDEO_SELECTED_READER:

         case PREF_VIDEO_SELECTED_WEB:

         case PREF_VIDEO_SELECTED_APP:

         case PREF_AUDIO_SELECTED_READER:

         case PREF_AUDIO_SELECTED_WEB:

         case PREF_AUDIO_SELECTED_APP:

           this._setSelectedHandler(feedType);

           break;

         case PREF_SELECTED_ACTION:

         case PREF_VIDEO_SELECTED_ACTION:

         case PREF_AUDIO_SELECTED_ACTION:

           this._setAlwaysUseCheckedState(feedType);

       }

     } 

   },

   /**

    * Sets the icon for the given web-reader item in the readers menu.

    * The icon is fetched and stored through the favicon service.

    *

    * @param aReaderUrl

    *        the reader url.

    * @param aMenuItem

    *        the reader item in the readers menulist.

    *

    * @note For privacy reasons we cannot set the image attribute directly

    *       to the icon url.  See Bug 358878 for details.

    */

   _setFaviconForWebReader:

   function FW__setFaviconForWebReader(aReaderUrl, aMenuItem) {

     var readerURI = makeURI(aReaderUrl);

     if (!/^https?$/.test(readerURI.scheme)) {

       // Don't try to get a favicon for non http(s) URIs.

       return;

     }

     var faviconURI = makeURI(readerURI.prePath + "/favicon.ico");

     var self = this;

     var usePrivateBrowsing = this._window.QueryInterface(Ci.nsIInterfaceRequestor)

                                          .getInterface(Ci.nsIWebNavigation)

                                          .QueryInterface(Ci.nsIDocShell)

                                          .QueryInterface(Ci.nsILoadContext)

                                          .usePrivateBrowsing;

     this._faviconService.setAndFetchFaviconForPage(readerURI, faviconURI, false,

       usePrivateBrowsing ? this._faviconService.FAVICON_LOAD_PRIVATE

                          : this._faviconService.FAVICON_LOAD_NON_PRIVATE,

       function (aURI, aDataLen, aData, aMimeType) {

         if (aDataLen > 0) {

           var dataURL = "data:" + aMimeType + ";base64," +

                         btoa(String.fromCharCode.apply(null, aData));

           self._contentSandbox.menuItem = aMenuItem;

           self._contentSandbox.dataURL = dataURL;

           var codeStr = "menuItem.setAttribute('image', dataURL);";

           Cu.evalInSandbox(codeStr, self._contentSandbox);

           self._contentSandbox.menuItem = null;

           self._contentSandbox.dataURL = null;

         }

       });

   },

   classID: FEEDWRITER_CID,

   QueryInterface: XPCOMUtils.generateQI([Ci.nsIDOMEventListener, Ci.nsIObserver,

                                          Ci.nsINavHistoryObserver,

                                          Ci.nsIDOMGlobalPropertyInitializer])

 };

 this.NSGetFactory = XPCOMUtils.generateNSGetFactory([FeedWriter]);