summaryrefslogtreecommitdiffstats
path: root/application/basilisk/components/feeds/FeedWriter.js
diff options
context:
space:
mode:
authorMatt A. Tobin <email@mattatobin.com>2018-02-02 03:32:58 -0500
committerMatt A. Tobin <email@mattatobin.com>2018-02-02 03:32:58 -0500
commite72ef92b5bdc43cd2584198e2e54e951b70299e8 (patch)
tree01ceb4a897c33eca9e7ccf2bc3aefbe530169fe5 /application/basilisk/components/feeds/FeedWriter.js
parent0d19b77d3eaa5b8d837bf52c19759e68e42a1c4c (diff)
downloadUXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar.gz
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar.lz
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar.xz
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.zip
Add Basilisk
Diffstat (limited to 'application/basilisk/components/feeds/FeedWriter.js')
-rw-r--r--application/basilisk/components/feeds/FeedWriter.js1000
1 files changed, 1000 insertions, 0 deletions
diff --git a/application/basilisk/components/feeds/FeedWriter.js b/application/basilisk/components/feeds/FeedWriter.js
new file mode 100644
index 000000000..751cb6534
--- /dev/null
+++ b/application/basilisk/components/feeds/FeedWriter.js
@@ -0,0 +1,1000 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+
+const FEEDWRITER_CID = Components.ID("{49bb6593-3aff-4eb3-a068-2712c28bd58e}");
+const FEEDWRITER_CONTRACTID = "@mozilla.org/browser/feeds/result-writer;1";
+
+function LOG(str) {
+ let prefB = Cc["@mozilla.org/preferences-service;1"].
+ getService(Ci.nsIPrefBranch);
+
+ let 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) {
+ let ios = Cc["@mozilla.org/network/io-service;1"].
+ getService(Ci.nsIIOService);
+ try {
+ return ios.newURI(aURLSpec, aCharset);
+ } 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 URI_BUNDLE = "chrome://browser/locale/feeds/subscribe.properties";
+
+const TITLE_ID = "feedTitleText";
+const SUBTITLE_ID = "feedSubtitleText";
+
+/**
+ * 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) {
+ let 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() {
+ this._selectedApp = undefined;
+ this._selectedAppMenuItem = null;
+ this._subscribeCallback = null;
+ this._defaultHandlerMenuItem = null;
+}
+
+FeedWriter.prototype = {
+ _getPropertyAsBag(container, property) {
+ return container.fields.getProperty(property).
+ QueryInterface(Ci.nsIPropertyBag2);
+ },
+
+ _getPropertyAsString(container, property) {
+ try {
+ return container.fields.getPropertyAsAString(property);
+ } catch (e) {
+ }
+ return "";
+ },
+
+ _setContentText(id, text) {
+ let element = this._document.getElementById(id);
+ let textNode = text.createDocumentFragment(element);
+ while (element.hasChildNodes())
+ element.removeChild(element.firstChild);
+ element.appendChild(textNode);
+ if (text.base) {
+ element.setAttributeNS(XML_NS, "base", text.base.spec);
+ }
+ },
+
+ /**
+ * 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(element, attribute, uri) {
+ let secman = Cc["@mozilla.org/scriptsecuritymanager;1"].
+ getService(Ci.nsIScriptSecurityManager);
+ const flags = Ci.nsIScriptSecurityManager.DISALLOW_INHERIT_PRINCIPAL;
+ try {
+ // TODO Is this necessary?
+ 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;
+ }
+
+ element.setAttribute(attribute, uri);
+ },
+
+ __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(key, params) {
+ return this._bundle.formatStringFromName(key, params, params.length);
+ },
+
+ _getString(key) {
+ return this._bundle.GetStringFromName(key);
+ },
+
+ _setCheckboxCheckedState(aValue) {
+ let checkbox = this._document.getElementById("alwaysUse");
+ if (checkbox) {
+ // see checkbox.xml, xbl bindings are not applied within the sandbox! TODO
+ let change = (aValue != (checkbox.getAttribute("checked") == "true"));
+ if (aValue)
+ checkbox.setAttribute("checked", "true");
+ else
+ checkbox.removeAttribute("checked");
+
+ if (change) {
+ let event = this._document.createEvent("Events");
+ event.initEvent("CheckboxStateChange", true, true);
+ checkbox.dispatchEvent(event);
+ }
+ }
+ },
+
+ /**
+ * 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(dateString) {
+ // Convert the date into the user's local time zone
+ let dateObj = new Date(dateString);
+
+ // Make sure the date we're given is valid.
+ if (!dateObj.getTime())
+ return false;
+
+ return this._dateFormatter.format(dateObj);
+ },
+
+ __dateFormatter: null,
+ get _dateFormatter() {
+ if (!this.__dateFormatter) {
+ const locale = Cc["@mozilla.org/chrome/chrome-registry;1"]
+ .getService(Ci.nsIXULChromeRegistry)
+ .getSelectedLocale("global", true);
+ const dtOptions = { year: "numeric", month: "long", day: "numeric",
+ hour: "numeric", minute: "numeric" };
+ this.__dateFormatter = new Intl.DateTimeFormat(locale, dtOptions);
+ }
+ return this.__dateFormatter;
+ },
+
+ /**
+ * Returns the feed type.
+ */
+ __feedType: null,
+ _getFeedType() {
+ if (this.__feedType != null)
+ return this.__feedType;
+
+ try {
+ // grab the feed because it's got the feed.type in it.
+ let container = this._getContainer();
+ let feed = container.QueryInterface(Ci.nsIFeed);
+ this.__feedType = feed.type;
+ return feed.type;
+ } catch (ex) { }
+
+ return Ci.nsIFeed.TYPE_FEED;
+ },
+
+ /**
+ * Writes the feed title into the preview document.
+ * @param container
+ * The feed container
+ */
+ _setTitleText(container) {
+ if (container.title) {
+ let title = container.title.plainText();
+ this._setContentText(TITLE_ID, container.title);
+ this._document.title = title;
+ }
+
+ let 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(container) {
+ try {
+ let parts = container.image;
+
+ // Set up the title image (supplied by the feed)
+ let feedTitleImage = this._document.getElementById("feedTitleImage");
+ this._safeSetURIAttribute(feedTitleImage, "src",
+ parts.getPropertyAsAString("url"));
+
+ // Set up the title image link
+ let feedTitleLink = this._document.getElementById("feedTitleLink");
+
+ let titleText = this._getFormattedString("linkTitleTextFormat",
+ [parts.getPropertyAsAString("title")]);
+ let feedTitleText = this._document.getElementById("feedTitleText");
+ let titleImageWidth = parseInt(parts.getPropertyAsAString("width")) + 15;
+
+ // Fix the margin on the main title, so that the image doesn't run over
+ // the underline
+ feedTitleLink.setAttribute("title", titleText);
+ feedTitleText.style.marginRight = titleImageWidth + "px";
+
+ 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(container) {
+ // Build the actual feed content
+ let feed = container.QueryInterface(Ci.nsIFeed);
+ if (feed.items.length == 0)
+ return;
+
+ let feedContent = this._document.getElementById("feedContent");
+
+ for (let i = 0; i < feed.items.length; ++i) {
+ let entry = feed.items.queryElementAt(i, Ci.nsIFeedEntry);
+ entry.QueryInterface(Ci.nsIFeedContainer);
+
+ let entryContainer = this._document.createElementNS(HTML_NS, "div");
+ entryContainer.className = "entry";
+
+ // If the entry has a title, make it a link
+ if (entry.title) {
+ let a = this._document.createElementNS(HTML_NS, "a");
+ let 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);
+
+ let title = this._document.createElementNS(HTML_NS, "h3");
+ title.appendChild(a);
+
+ let lastUpdated = this._parseDate(entry.updated);
+ if (lastUpdated) {
+ let dateDiv = this._document.createElementNS(HTML_NS, "div");
+ dateDiv.className = "lastUpdated";
+ dateDiv.textContent = lastUpdated;
+ title.appendChild(dateDiv);
+ }
+
+ entryContainer.appendChild(title);
+ }
+
+ let body = this._document.createElementNS(HTML_NS, "div");
+ let summary = entry.summary || entry.content;
+ let 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) {
+ let 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) {
+ let enclosuresDiv = this._buildEnclosureDiv(entry);
+ entryContainer.appendChild(enclosuresDiv);
+ }
+
+ let clearDiv = this._document.createElementNS(HTML_NS, "div");
+ clearDiv.style.clear = "both";
+
+ feedContent.appendChild(entryContainer);
+ feedContent.appendChild(clearDiv);
+ }
+ },
+
+ /**
+ * 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(aURL) {
+ let 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(entry) {
+ let enclosuresDiv = this._document.createElementNS(HTML_NS, "div");
+ enclosuresDiv.className = "enclosures";
+
+ enclosuresDiv.appendChild(this._document.createTextNode(this._getString("mediaLabel")));
+
+ for (let i_enc = 0; i_enc < entry.enclosures.length; ++i_enc) {
+ let enc = entry.enclosures.queryElementAt(i_enc, Ci.nsIWritablePropertyBag2);
+
+ if (!(enc.hasKey("url")))
+ continue;
+
+ let enclosureDiv = this._document.createElementNS(HTML_NS, "div");
+ enclosureDiv.setAttribute("class", "enclosure");
+
+ let mozicon = "moz-icon://.txt?size=16";
+ let type_text = null;
+ let size_text = null;
+
+ if (enc.hasKey("type")) {
+ type_text = enc.get("type");
+ if (enc.hasKey("typeDesc"))
+ type_text = enc.get("typeDesc");
+
+ if (type_text && type_text.length > 0)
+ mozicon = "moz-icon://goat?size=16&contentType=" + enc.get("type");
+ }
+
+ if (enc.hasKey("length") && /^[0-9]+$/.test(enc.get("length"))) {
+ let enc_size = convertByteUnits(parseInt(enc.get("length")));
+
+ size_text = this._getFormattedString("enclosureSizeText",
+ [enc_size[0],
+ this._getString(enc_size[1])]);
+ }
+
+ let iconimg = this._document.createElementNS(HTML_NS, "img");
+ iconimg.setAttribute("src", mozicon);
+ iconimg.setAttribute("class", "type-icon");
+ enclosureDiv.appendChild(iconimg);
+
+ enclosureDiv.appendChild(this._document.createTextNode( " " ));
+
+ let 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.
+ * @returns A valid nsIFeedContainer object containing the contents of
+ * the feed.
+ */
+ _getContainer() {
+ let feedService =
+ Cc["@mozilla.org/browser/feeds/result-service;1"].
+ getService(Ci.nsIFeedResultService);
+
+ let result;
+ try {
+ 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?!");
+ }
+
+ let container;
+ try {
+ container = result.doc;
+ } catch (e) {
+ LOG("Subscribe Preview: no result.doc? Why didn't the original reload?");
+ return null;
+ }
+ return container;
+ },
+
+ /**
+ * 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(file) {
+ let ios = Cc["@mozilla.org/network/io-service;1"].
+ getService(Ci.nsIIOService);
+ let fph = ios.getProtocolHandler("file")
+ .QueryInterface(Ci.nsIFileProtocolHandler);
+ let urlSpec = fph.getURLSpecFromFile(file);
+ return "moz-icon://" + urlSpec + "?size=16";
+ },
+
+ /**
+ * 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(aCallback) {
+ this._subscribeCallback = aCallback;
+ this._mm.sendAsyncMessage("FeedWriter:ChooseClientApp",
+ { title: this._getString("chooseApplicationDialogTitle"),
+ feedType: this._getFeedType() });
+ },
+
+ _setSubscribeUsingLabel() {
+ let stringLabel = "subscribeFeedUsing";
+ switch (this._getFeedType()) {
+ case Ci.nsIFeed.TYPE_VIDEO:
+ stringLabel = "subscribeVideoPodcastUsing";
+ break;
+
+ case Ci.nsIFeed.TYPE_AUDIO:
+ stringLabel = "subscribeAudioPodcastUsing";
+ break;
+ }
+
+ let subscribeUsing = this._document.getElementById("subscribeUsingDescription");
+ let textNode = this._document.createTextNode(this._getString(stringLabel));
+ subscribeUsing.insertBefore(textNode, subscribeUsing.firstChild);
+ },
+
+ _setAlwaysUseLabel() {
+ let checkbox = this._document.getElementById("alwaysUse");
+ if (checkbox && this._handlersList) {
+ let handlerName = this._handlersList.selectedOptions[0]
+ .textContent;
+ let stringLabel = "alwaysUseForFeeds";
+ switch (this._getFeedType()) {
+ case Ci.nsIFeed.TYPE_VIDEO:
+ stringLabel = "alwaysUseForVideoPodcasts";
+ break;
+
+ case Ci.nsIFeed.TYPE_AUDIO:
+ stringLabel = "alwaysUseForAudioPodcasts";
+ break;
+ }
+
+ let label = this._getFormattedString(stringLabel, [handlerName]);
+
+ let checkboxText = this._document.getElementById("checkboxText");
+ if (checkboxText.lastChild.nodeType == checkboxText.TEXT_NODE) {
+ checkboxText.lastChild.textContent = label;
+ } else {
+ LOG("FeedWriter._setAlwaysUseLabel: Expected textNode as lastChild of alwaysUse label");
+ let textNode = this._document.createTextNode(label);
+ checkboxText.appendChild(textNode);
+ }
+ }
+ },
+
+ // nsIDomEventListener
+ handleEvent(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;
+ }
+
+ switch (event.type) {
+ case "click":
+ if (event.target.id == "subscribeButton") {
+ this.subscribe();
+ }
+ break;
+ case "change":
+ LOG("Change fired");
+ if (event.target.selectedOptions[0].id == "chooseApplicationMenuItem") {
+ this._chooseClientApp(() => {
+ // Select the (per-prefs) selected handler if no application
+ // was selected
+ LOG("Selected handler after callback");
+ this._setAlwaysUseLabel();
+ });
+ } else {
+ this._setAlwaysUseLabel();
+ }
+ break;
+ }
+ },
+
+ _getWebHandlerElementsForURL(aURL) {
+ return this._handlersList.querySelectorAll('[webhandlerurl="' + aURL + '"]');
+ },
+
+ _setSelectedHandlerResponse(handler, url) {
+ LOG(`Selecting handler response ${handler} ${url}`);
+ switch (handler) {
+ case "web": {
+ if (this._handlersList) {
+ let handlers =
+ this._getWebHandlerElementsForURL(url);
+ if (handlers.length == 0) {
+ LOG(`Selected web handler isn't in the menulist ${url}`);
+ return;
+ }
+
+ handlers[0].selected = true;
+ }
+ break;
+ }
+ case "client":
+ case "default":
+ // do nothing, these are handled by the onchange event
+ break;
+ case "bookmarks":
+ default: {
+ let liveBookmarksMenuItem = this._document.getElementById("liveBookmarksMenuItem");
+ if (liveBookmarksMenuItem)
+ liveBookmarksMenuItem.selected = true;
+ }
+ }
+ },
+
+ _initSubscriptionUI(setupMessage) {
+ if (!this._handlersList)
+ return;
+ LOG("UI init");
+
+ let feedType = this._getFeedType();
+
+ // change the background
+ let header = this._document.getElementById("feedHeader");
+ switch (feedType) {
+ case Ci.nsIFeed.TYPE_VIDEO:
+ header.className = "videoPodcastBackground";
+ break;
+
+ case Ci.nsIFeed.TYPE_AUDIO:
+ header.className = "audioPodcastBackground";
+ break;
+
+ default:
+ header.className = "feedBackground";
+ }
+
+ let liveBookmarksMenuItem = this._document.getElementById("liveBookmarksMenuItem");
+
+ // Last-selected application
+ let menuItem = liveBookmarksMenuItem.cloneNode(false);
+ menuItem.removeAttribute("selected");
+ menuItem.setAttribute("id", "selectedAppMenuItem");
+ menuItem.setAttribute("handlerType", "client");
+
+ // Hide the menuitem until we select an app
+ menuItem.style.display = "none";
+ this._selectedAppMenuItem = menuItem;
+
+ this._handlersList.appendChild(this._selectedAppMenuItem);
+
+ // Create the menuitem for the default reader, but don't show/populate it until
+ // we get confirmation of what it is from the parent
+ menuItem = liveBookmarksMenuItem.cloneNode(false);
+ menuItem.removeAttribute("selected");
+ menuItem.setAttribute("id", "defaultHandlerMenuItem");
+ menuItem.setAttribute("handlerType", "client");
+ menuItem.style.display = "none";
+
+ this._defaultHandlerMenuItem = menuItem;
+ this._handlersList.appendChild(this._defaultHandlerMenuItem);
+
+ // "Choose Application..." menuitem
+ menuItem = liveBookmarksMenuItem.cloneNode(false);
+ menuItem.removeAttribute("selected");
+ menuItem.setAttribute("id", "chooseApplicationMenuItem");
+ menuItem.textContent = this._getString("chooseApplicationMenuItem");
+
+ this._handlersList.appendChild(menuItem);
+
+ // separator
+ let chooseAppSep = liveBookmarksMenuItem.nextElementSibling.cloneNode(false);
+ chooseAppSep.textContent = liveBookmarksMenuItem.nextElementSibling.textContent;
+ this._handlersList.appendChild(chooseAppSep);
+
+ for (let handler of setupMessage.handlers) {
+ if (!handler.uri) {
+ LOG("Handler with name " + handler.name + " has no URI!? Skipping...");
+ continue;
+ }
+ menuItem = liveBookmarksMenuItem.cloneNode(false);
+ menuItem.removeAttribute("selected");
+ menuItem.className = "menuitem-iconic";
+ menuItem.textContent = handler.name;
+ menuItem.setAttribute("handlerType", "web");
+ menuItem.setAttribute("webhandlerurl", handler.uri);
+ this._handlersList.appendChild(menuItem);
+ }
+
+ this._setSelectedHandlerResponse(setupMessage.reader.handler, setupMessage.reader.url);
+
+ if (setupMessage.defaultMenuItem) {
+ LOG(`Setting default menu item ${setupMessage.defaultMenuItem}`);
+ this._setApplicationLauncherMenuItem(this._defaultHandlerMenuItem, setupMessage.defaultMenuItem);
+ }
+ if (setupMessage.selectedMenuItem) {
+ LOG(`Setting selected menu item ${setupMessage.selectedMenuItem}`);
+ this._setApplicationLauncherMenuItem(this._selectedAppMenuItem, setupMessage.selectedMenuItem);
+ }
+
+ // "Subscribe using..."
+ this._setSubscribeUsingLabel();
+
+ // "Always use..." checkbox initial state
+ this._setCheckboxCheckedState(setupMessage.reader.alwaysUse);
+ this._setAlwaysUseLabel();
+
+ // We update the "Always use.." checkbox label whenever the selected item
+ // in the list is changed
+ this._handlersList.addEventListener("change", this);
+
+ // Set up the "Subscribe Now" button
+ this._document.getElementById("subscribeButton")
+ .addEventListener("click", this);
+
+ // first-run ui
+ if (setupMessage.showFirstRunUI) {
+ let 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";
+ }
+
+ let feedinfo1 = this._document.getElementById("feedSubscriptionInfo1");
+ let feedinfo1Str = this._getString(textfeedinfo1);
+ let feedinfo2 = this._document.getElementById("feedSubscriptionInfo2");
+ let feedinfo2Str = this._getString(textfeedinfo2);
+
+ feedinfo1.textContent = feedinfo1Str;
+ feedinfo2.textContent = feedinfo2Str;
+
+ header.setAttribute("firstrun", "true");
+
+ this._mm.sendAsyncMessage("FeedWriter:ShownFirstRun");
+ }
+ },
+
+ /**
+ * 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(aWindow) {
+ let docShell = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIWebNavigation)
+ .QueryInterface(Ci.nsIDocShell);
+ let chan = docShell.currentDocumentChannel;
+
+ // We probably need to call Inherit() for this, but right now we can't call
+ // it from JS.
+ let attrs = docShell.getOriginAttributes();
+ let ssm = Services.scriptSecurityManager;
+ let nullPrincipal = ssm.createNullPrincipal(attrs);
+
+ // this channel is not going to be openend, use a nullPrincipal
+ // and the most restrctive securityFlag.
+ let resolvedURI = NetUtil.newChannel({
+ uri: "about:feeds",
+ loadingPrincipal: nullPrincipal,
+ securityFlags: Ci.nsILoadInfo.SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED,
+ contentPolicyType: Ci.nsIContentPolicy.TYPE_OTHER
+ }).URI;
+
+ if (resolvedURI.equals(chan.URI))
+ return chan.originalURI;
+
+ return null;
+ },
+
+ _window: null,
+ _document: null,
+ _feedURI: null,
+ _feedPrincipal: null,
+ _handlersList: null,
+
+ // BrowserFeedWriter WebIDL methods
+ init(aWindow) {
+ let window = aWindow;
+ this._feedURI = this._getOriginalURI(window);
+ if (!this._feedURI)
+ return;
+
+ this._window = window;
+ this._document = window.document;
+ this._handlersList = this._document.getElementById("handlersMenuList");
+
+ let secman = Cc["@mozilla.org/scriptsecuritymanager;1"].
+ getService(Ci.nsIScriptSecurityManager);
+ this._feedPrincipal = secman.createCodebasePrincipal(this._feedURI, {});
+
+ LOG("Subscribe Preview: feed uri = " + this._window.location.href);
+
+
+ this._mm.addMessageListener("FeedWriter:PreferenceUpdated", this);
+ this._mm.addMessageListener("FeedWriter:SetApplicationLauncherMenuItem", this);
+ this._mm.addMessageListener("FeedWriter:GetSubscriptionUIResponse", this);
+ this._mm.addMessageListener("FeedWriter:SetFeedPrefsAndSubscribeResponse", this);
+
+ const feedType = this._getFeedType();
+ this._mm.sendAsyncMessage("FeedWriter:GetSubscriptionUI",
+ { feedType });
+ },
+
+ receiveMessage(msg) {
+ if (!this._window) {
+ // this._window is null unless this.init was called with a trusted
+ // window object.
+ return;
+ }
+ LOG(`received message from parent ${msg.name}`);
+ switch (msg.name) {
+ case "FeedWriter:PreferenceUpdated":
+ // This is called when browser-feeds.js spots a pref change
+ // This will happen when
+ // - about:preferences#applications changes
+ // - another feed reader page changes the preference
+ // - when this page itself changes the select and there isn't a redirect
+ // bookmarks and launching an external app means the page stays open after subscribe
+ const feedType = this._getFeedType();
+ LOG(`Got prefChange! ${JSON.stringify(msg.data)} current type: ${feedType}`);
+ let feedTypePref = msg.data.default;
+ if (feedType in msg.data) {
+ feedTypePref = msg.data[feedType];
+ }
+ LOG(`Got pref ${JSON.stringify(feedTypePref)}`);
+ this._setCheckboxCheckedState(feedTypePref.alwaysUse);
+ this._setSelectedHandlerResponse(feedTypePref.handler, feedTypePref.url);
+ this._setAlwaysUseLabel();
+ break;
+ case "FeedWriter:SetFeedPrefsAndSubscribeResponse":
+ LOG(`FeedWriter:SetFeedPrefsAndSubscribeResponse - Redirecting ${msg.data.redirect}`);
+ this._window.location.href = msg.data.redirect;
+ break;
+ case "FeedWriter:GetSubscriptionUIResponse":
+ // Set up the subscription UI
+ this._initSubscriptionUI(msg.data);
+ break;
+ case "FeedWriter:SetApplicationLauncherMenuItem":
+ LOG(`FeedWriter:SetApplicationLauncherMenuItem - picked ${msg.data.name}`);
+ this._setApplicationLauncherMenuItem(this._selectedAppMenuItem, msg.data.name);
+ // Potentially a bit racy, but I don't think we can get into a state where this callback is set and
+ // we're not coming back from ChooseClientApp in browser-feeds.js
+ if (this._subscribeCallback) {
+ this._subscribeCallback();
+ this._subscribeCallback = null;
+ }
+ break;
+ }
+ },
+
+ _setApplicationLauncherMenuItem(menuItem, aName) {
+ /* unselect all handlers */
+ [...this._handlersList.children].forEach((option) => {
+ option.removeAttribute("selected");
+ });
+ menuItem.textContent = aName;
+ menuItem.style.display = "";
+ menuItem.selected = true;
+ },
+
+ writeContent() {
+ if (!this._window)
+ return;
+
+ try {
+ // Set up the feed content
+ let container = this._getContainer();
+ if (!container)
+ return;
+
+ this._setTitleText(container);
+ this._setTitleImage(container);
+ this._writeFeedContent(container);
+ } finally {
+ this._removeFeedFromCache();
+ }
+ },
+
+ close() {
+ this._document.getElementById("subscribeButton")
+ .removeEventListener("click", this);
+ this._handlersList
+ .removeEventListener("change", this);
+ this._document = null;
+ this._window = null;
+ this._handlersList = null;
+
+ this._removeFeedFromCache();
+ this.__bundle = null;
+ this._feedURI = null;
+
+ this._selectedApp = undefined;
+ this._selectedAppMenuItem = null;
+ this._defaultHandlerMenuItem = null;
+ },
+
+ _removeFeedFromCache() {
+ if (this._feedURI) {
+ let feedService = Cc["@mozilla.org/browser/feeds/result-service;1"].
+ getService(Ci.nsIFeedResultService);
+ feedService.removeFeedResult(this._feedURI);
+ this._feedURI = null;
+ }
+ },
+
+ subscribe() {
+ let feedType = this._getFeedType();
+
+ // Subscribe to the feed using the selected handler and save prefs
+ let defaultHandler = "reader";
+ let useAsDefault = this._document.getElementById("alwaysUse").getAttribute("checked");
+
+ let selectedItem = this._handlersList.selectedOptions[0];
+ let subscribeCallback = () => {
+ let feedReader = null;
+ let settings = {
+ feedType,
+ useAsDefault,
+ // Pull the title and subtitle out of the document
+ feedTitle: this._document.getElementById(TITLE_ID).textContent,
+ feedSubtitle: this._document.getElementById(SUBTITLE_ID).textContent,
+ feedLocation: this._window.location.href
+ };
+ if (selectedItem.hasAttribute("webhandlerurl")) {
+ feedReader = "web";
+ settings.uri = selectedItem.getAttribute("webhandlerurl");
+ } else {
+ switch (selectedItem.id) {
+ case "selectedAppMenuItem":
+ feedReader = "client";
+ break;
+ case "defaultHandlerMenuItem":
+ feedReader = "default";
+ break;
+ case "liveBookmarksMenuItem":
+ defaultHandler = "bookmarks";
+ feedReader = "bookmarks";
+ break;
+ }
+ }
+ settings.reader = feedReader;
+
+ // 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) {
+ defaultHandler = "ask";
+ }
+ settings.action = defaultHandler;
+ LOG(`FeedWriter:SetFeedPrefsAndSubscribe - ${JSON.stringify(settings)}`);
+ this._mm.sendAsyncMessage("FeedWriter:SetFeedPrefsAndSubscribe",
+ settings);
+ }
+
+ // Show the file picker before subscribing if the
+ // choose application menuitem was chosen using the keyboard
+ if (selectedItem.id == "chooseApplicationMenuItem") {
+ this._chooseClientApp(function(aResult) {
+ if (aResult) {
+ selectedItem =
+ this._handlersList.selectedOptions[0];
+ subscribeCallback();
+ }
+ }.bind(this));
+ } else {
+ subscribeCallback();
+ }
+ },
+
+ get _mm() {
+ let mm = this._window.QueryInterface(Ci.nsIInterfaceRequestor).
+ getInterface(Ci.nsIDocShell).
+ QueryInterface(Ci.nsIInterfaceRequestor).
+ getInterface(Ci.nsIContentFrameMessageManager);
+ delete this._mm;
+ return this._mm = mm;
+ },
+
+ classID: FEEDWRITER_CID,
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsIDOMEventListener, Ci.nsIObserver,
+ Ci.nsINavHistoryObserver,
+ Ci.nsIDOMGlobalPropertyInitializer])
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([FeedWriter]);