summaryrefslogtreecommitdiffstats
path: root/application/basilisk/modules/PluginContent.jsm
diff options
context:
space:
mode:
Diffstat (limited to 'application/basilisk/modules/PluginContent.jsm')
-rw-r--r--application/basilisk/modules/PluginContent.jsm1182
1 files changed, 1182 insertions, 0 deletions
diff --git a/application/basilisk/modules/PluginContent.jsm b/application/basilisk/modules/PluginContent.jsm
new file mode 100644
index 000000000..40c4559a1
--- /dev/null
+++ b/application/basilisk/modules/PluginContent.jsm
@@ -0,0 +1,1182 @@
+/* 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";
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = [ "PluginContent" ];
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Timer.jsm");
+Cu.import("resource://gre/modules/BrowserUtils.jsm");
+
+XPCOMUtils.defineLazyGetter(this, "gNavigatorBundle", function() {
+ const url = "chrome://browser/locale/browser.properties";
+ return Services.strings.createBundle(url);
+});
+
+this.PluginContent = function(global) {
+ this.init(global);
+}
+
+const FLASH_MIME_TYPE = "application/x-shockwave-flash";
+const REPLACEMENT_STYLE_SHEET = Services.io.newURI("chrome://pluginproblem/content/pluginReplaceBinding.css");
+
+PluginContent.prototype = {
+ init(global) {
+ this.global = global;
+ // Need to hold onto the content window or else it'll get destroyed
+ this.content = this.global.content;
+ // Cache of plugin actions for the current page.
+ this.pluginData = new Map();
+ // Cache of plugin crash information sent from the parent
+ this.pluginCrashData = new Map();
+
+ // Note that the XBL binding is untrusted
+ global.addEventListener("PluginBindingAttached", this, true, true);
+ global.addEventListener("PluginPlaceholderReplaced", this, true, true);
+ global.addEventListener("PluginCrashed", this, true);
+ global.addEventListener("PluginOutdated", this, true);
+ global.addEventListener("PluginInstantiated", this, true);
+ global.addEventListener("PluginRemoved", this, true);
+ global.addEventListener("pagehide", this, true);
+ global.addEventListener("pageshow", this, true);
+ global.addEventListener("unload", this);
+ global.addEventListener("HiddenPlugin", this, true);
+
+ global.addMessageListener("BrowserPlugins:ActivatePlugins", this);
+ global.addMessageListener("BrowserPlugins:NotificationShown", this);
+ global.addMessageListener("BrowserPlugins:ContextMenuCommand", this);
+ global.addMessageListener("BrowserPlugins:NPAPIPluginProcessCrashed", this);
+ global.addMessageListener("BrowserPlugins:CrashReportSubmitted", this);
+ global.addMessageListener("BrowserPlugins:Test:ClearCrashData", this);
+
+ Services.obs.addObserver(this, "decoder-doctor-notification", false);
+ },
+
+ uninit() {
+ let global = this.global;
+
+ global.removeEventListener("PluginBindingAttached", this, true);
+ global.removeEventListener("PluginPlaceholderReplaced", this, true, true);
+ global.removeEventListener("PluginCrashed", this, true);
+ global.removeEventListener("PluginOutdated", this, true);
+ global.removeEventListener("PluginInstantiated", this, true);
+ global.removeEventListener("PluginRemoved", this, true);
+ global.removeEventListener("pagehide", this, true);
+ global.removeEventListener("pageshow", this, true);
+ global.removeEventListener("unload", this);
+ global.removeEventListener("HiddenPlugin", this, true);
+
+ global.removeMessageListener("BrowserPlugins:ActivatePlugins", this);
+ global.removeMessageListener("BrowserPlugins:NotificationShown", this);
+ global.removeMessageListener("BrowserPlugins:ContextMenuCommand", this);
+ global.removeMessageListener("BrowserPlugins:NPAPIPluginProcessCrashed", this);
+ global.removeMessageListener("BrowserPlugins:CrashReportSubmitted", this);
+ global.removeMessageListener("BrowserPlugins:Test:ClearCrashData", this);
+
+ Services.obs.removeObserver(this, "decoder-doctor-notification");
+
+ delete this.global;
+ delete this.content;
+ },
+
+ receiveMessage(msg) {
+ switch (msg.name) {
+ case "BrowserPlugins:ActivatePlugins":
+ this.activatePlugins(msg.data.pluginInfo, msg.data.newState);
+ break;
+ case "BrowserPlugins:NotificationShown":
+ setTimeout(() => this.updateNotificationUI(), 0);
+ break;
+ case "BrowserPlugins:ContextMenuCommand":
+ switch (msg.data.command) {
+ case "play":
+ this._showClickToPlayNotification(msg.objects.plugin, true);
+ break;
+ case "hide":
+ this.hideClickToPlayOverlay(msg.objects.plugin);
+ break;
+ }
+ break;
+ case "BrowserPlugins:NPAPIPluginProcessCrashed":
+ this.NPAPIPluginProcessCrashed({
+ pluginName: msg.data.pluginName,
+ runID: msg.data.runID,
+ state: msg.data.state,
+ });
+ break;
+ case "BrowserPlugins:CrashReportSubmitted":
+ this.NPAPIPluginCrashReportSubmitted({
+ runID: msg.data.runID,
+ state: msg.data.state,
+ })
+ break;
+ case "BrowserPlugins:Test:ClearCrashData":
+ // This message should ONLY ever be sent by automated tests.
+ if (Services.prefs.getBoolPref("plugins.testmode")) {
+ this.pluginCrashData.clear();
+ }
+ }
+ },
+
+ observe: function observe(aSubject, aTopic, aData) {
+ switch (aTopic) {
+ case "decoder-doctor-notification":
+ let data = JSON.parse(aData);
+ let type = data.type.toLowerCase();
+ if (type == "cannot-play" &&
+ this.haveShownNotification &&
+ aSubject.top.document == this.content.document &&
+ data.formats.toLowerCase().includes("application/x-mpegurl", 0)) {
+ this.global.content.pluginRequiresReload = true;
+ this.updateNotificationUI(this.content.document);
+ }
+ }
+ },
+
+ onPageShow(event) {
+ // Ignore events that aren't from the main document.
+ if (!this.content || event.target != this.content.document) {
+ return;
+ }
+
+ // The PluginClickToPlay events are not fired when navigating using the
+ // BF cache. |persisted| is true when the page is loaded from the
+ // BF cache, so this code reshows the notification if necessary.
+ if (event.persisted) {
+ this.reshowClickToPlayNotification();
+ }
+ },
+
+ onPageHide(event) {
+ // Ignore events that aren't from the main document.
+ if (!this.content || event.target != this.content.document) {
+ return;
+ }
+
+ this._finishRecordingFlashPluginTelemetry();
+ this.clearPluginCaches();
+ this.haveShownNotification = false;
+ },
+
+ getPluginUI(plugin, anonid) {
+ return plugin.ownerDocument.
+ getAnonymousElementByAttribute(plugin, "anonid", anonid);
+ },
+
+ _getPluginInfo(pluginElement) {
+ if (pluginElement instanceof Ci.nsIDOMHTMLAnchorElement) {
+ // Anchor elements are our place holders, and we only have them for Flash
+ let pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ return {
+ pluginName: "Shockwave Flash",
+ mimetype: FLASH_MIME_TYPE,
+ permissionString: pluginHost.getPermissionStringForType(FLASH_MIME_TYPE)
+ };
+ }
+ let pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ pluginElement.QueryInterface(Ci.nsIObjectLoadingContent);
+
+ let tagMimetype;
+ let pluginName = gNavigatorBundle.GetStringFromName("pluginInfo.unknownPlugin");
+ let pluginTag = null;
+ let permissionString = null;
+ let fallbackType = null;
+ let blocklistState = null;
+
+ tagMimetype = pluginElement.actualType;
+ if (tagMimetype == "") {
+ tagMimetype = pluginElement.type;
+ }
+
+ if (this.isKnownPlugin(pluginElement)) {
+ pluginTag = pluginHost.getPluginTagForType(pluginElement.actualType);
+ pluginName = BrowserUtils.makeNicePluginName(pluginTag.name);
+
+ // Convert this from nsIPluginTag so it can be serialized.
+ let properties = ["name", "description", "filename", "version", "enabledState", "niceName"];
+ let pluginTagCopy = {};
+ for (let prop of properties) {
+ pluginTagCopy[prop] = pluginTag[prop];
+ }
+ pluginTag = pluginTagCopy;
+
+ permissionString = pluginHost.getPermissionStringForType(pluginElement.actualType);
+ fallbackType = pluginElement.defaultFallbackType;
+ blocklistState = pluginHost.getBlocklistStateForType(pluginElement.actualType);
+ // Make state-softblocked == state-notblocked for our purposes,
+ // they have the same UI. STATE_OUTDATED should not exist for plugin
+ // items, but let's alias it anyway, just in case.
+ if (blocklistState == Ci.nsIBlocklistService.STATE_SOFTBLOCKED ||
+ blocklistState == Ci.nsIBlocklistService.STATE_OUTDATED) {
+ blocklistState = Ci.nsIBlocklistService.STATE_NOT_BLOCKED;
+ }
+ }
+
+ return { mimetype: tagMimetype,
+ pluginName,
+ pluginTag,
+ permissionString,
+ fallbackType,
+ blocklistState,
+ };
+ },
+
+ /**
+ * _getPluginInfoForTag is called when iterating the plugins for a document,
+ * and what we get from nsIDOMWindowUtils is an nsIPluginTag, and not an
+ * nsIObjectLoadingContent. This only should happen if the plugin is
+ * click-to-play (see bug 1186948).
+ */
+ _getPluginInfoForTag(pluginTag, tagMimetype) {
+ let pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+
+ let pluginName = gNavigatorBundle.GetStringFromName("pluginInfo.unknownPlugin");
+ let permissionString = null;
+ let blocklistState = null;
+
+ if (pluginTag) {
+ pluginName = BrowserUtils.makeNicePluginName(pluginTag.name);
+
+ permissionString = pluginHost.getPermissionStringForTag(pluginTag);
+ blocklistState = pluginTag.blocklistState;
+
+ // Convert this from nsIPluginTag so it can be serialized.
+ let properties = ["name", "description", "filename", "version", "enabledState", "niceName"];
+ let pluginTagCopy = {};
+ for (let prop of properties) {
+ pluginTagCopy[prop] = pluginTag[prop];
+ }
+ pluginTag = pluginTagCopy;
+
+ // Make state-softblocked == state-notblocked for our purposes,
+ // they have the same UI. STATE_OUTDATED should not exist for plugin
+ // items, but let's alias it anyway, just in case.
+ if (blocklistState == Ci.nsIBlocklistService.STATE_SOFTBLOCKED ||
+ blocklistState == Ci.nsIBlocklistService.STATE_OUTDATED) {
+ blocklistState = Ci.nsIBlocklistService.STATE_NOT_BLOCKED;
+ }
+ }
+
+ return { mimetype: tagMimetype,
+ pluginName,
+ pluginTag,
+ permissionString,
+ // Since we should only have entered _getPluginInfoForTag when
+ // examining a click-to-play plugin, we can safely hard-code
+ // this fallback type, since we don't actually have an
+ // nsIObjectLoadingContent to check.
+ fallbackType: Ci.nsIObjectLoadingContent.PLUGIN_CLICK_TO_PLAY,
+ blocklistState,
+ };
+ },
+
+ /**
+ * Update the visibility of the plugin overlay.
+ */
+ setVisibility(plugin, overlay, shouldShow) {
+ overlay.classList.toggle("visible", shouldShow);
+ if (shouldShow) {
+ overlay.removeAttribute("dismissed");
+ }
+ },
+
+ /**
+ * Check whether the plugin should be visible on the page. A plugin should
+ * not be visible if the overlay is too big, or if any other page content
+ * overlays it.
+ *
+ * This function will handle showing or hiding the overlay.
+ * @returns true if the plugin is invisible.
+ */
+ shouldShowOverlay(plugin, overlay) {
+ // If the overlay size is 0, we haven't done layout yet. Presume that
+ // plugins are visible until we know otherwise.
+ if (overlay.scrollWidth == 0) {
+ return true;
+ }
+
+ // Is the <object>'s size too small to hold what we want to show?
+ let pluginRect = plugin.getBoundingClientRect();
+ // XXX bug 446693. The text-shadow on the submitted-report text at
+ // the bottom causes scrollHeight to be larger than it should be.
+ let overflows = (overlay.scrollWidth > Math.ceil(pluginRect.width)) ||
+ (overlay.scrollHeight - 5 > Math.ceil(pluginRect.height));
+ if (overflows) {
+ return false;
+ }
+
+ // Is the plugin covered up by other content so that it is not clickable?
+ // Floating point can confuse .elementFromPoint, so inset just a bit
+ let left = pluginRect.left + 2;
+ let right = pluginRect.right - 2;
+ let top = pluginRect.top + 2;
+ let bottom = pluginRect.bottom - 2;
+ let centerX = left + (right - left) / 2;
+ let centerY = top + (bottom - top) / 2;
+ let points = [[left, top],
+ [left, bottom],
+ [right, top],
+ [right, bottom],
+ [centerX, centerY]];
+
+ if (right <= 0 || top <= 0) {
+ return false;
+ }
+
+ let contentWindow = plugin.ownerGlobal;
+ let cwu = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+
+ for (let [x, y] of points) {
+ let el = cwu.elementFromPoint(x, y, true, true);
+ if (el !== plugin) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+
+ addLinkClickCallback(linkNode, callbackName /* callbackArgs...*/) {
+ // XXX just doing (callback)(arg) was giving a same-origin error. bug?
+ let self = this;
+ let callbackArgs = Array.prototype.slice.call(arguments).slice(2);
+ linkNode.addEventListener("click",
+ function(evt) {
+ if (!evt.isTrusted)
+ return;
+ evt.preventDefault();
+ if (callbackArgs.length == 0)
+ callbackArgs = [ evt ];
+ (self[callbackName]).apply(self, callbackArgs);
+ },
+ true);
+
+ linkNode.addEventListener("keydown",
+ function(evt) {
+ if (!evt.isTrusted)
+ return;
+ if (evt.keyCode == evt.DOM_VK_RETURN) {
+ evt.preventDefault();
+ if (callbackArgs.length == 0)
+ callbackArgs = [ evt ];
+ evt.preventDefault();
+ (self[callbackName]).apply(self, callbackArgs);
+ }
+ },
+ true);
+ },
+
+ // Helper to get the binding handler type from a plugin object
+ _getBindingType(plugin) {
+ if (!(plugin instanceof Ci.nsIObjectLoadingContent))
+ return null;
+
+ switch (plugin.pluginFallbackType) {
+ case Ci.nsIObjectLoadingContent.PLUGIN_UNSUPPORTED:
+ return "PluginNotFound";
+ case Ci.nsIObjectLoadingContent.PLUGIN_DISABLED:
+ return "PluginDisabled";
+ case Ci.nsIObjectLoadingContent.PLUGIN_BLOCKLISTED:
+ return "PluginBlocklisted";
+ case Ci.nsIObjectLoadingContent.PLUGIN_OUTDATED:
+ return "PluginOutdated";
+ case Ci.nsIObjectLoadingContent.PLUGIN_CLICK_TO_PLAY:
+ return "PluginClickToPlay";
+ case Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_UPDATABLE:
+ return "PluginVulnerableUpdatable";
+ case Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_NO_UPDATE:
+ return "PluginVulnerableNoUpdate";
+ default:
+ // Not all states map to a handler
+ return null;
+ }
+ },
+
+ handleEvent(event) {
+ let eventType = event.type;
+
+ if (eventType == "unload") {
+ this.uninit();
+ return;
+ }
+
+ if (eventType == "pagehide") {
+ this.onPageHide(event);
+ return;
+ }
+
+ if (eventType == "pageshow") {
+ this.onPageShow(event);
+ return;
+ }
+
+ if (eventType == "PluginRemoved") {
+ this.updateNotificationUI(event.target);
+ return;
+ }
+
+ if (eventType == "click") {
+ this.onOverlayClick(event);
+ return;
+ }
+
+ if (eventType == "PluginCrashed" &&
+ !(event.target instanceof Ci.nsIObjectLoadingContent)) {
+ // If the event target is not a plugin object (i.e., an <object> or
+ // <embed> element), this call is for a window-global plugin.
+ this.onPluginCrashed(event.target, event);
+ return;
+ }
+
+ if (eventType == "HiddenPlugin") {
+ let win = event.target.defaultView;
+ if (!win.mozHiddenPluginTouched) {
+ let pluginTag = event.tag.QueryInterface(Ci.nsIPluginTag);
+ if (win.top.document != this.content.document) {
+ return;
+ }
+ this._showClickToPlayNotification(pluginTag, false);
+ let winUtils = win.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
+ try {
+ winUtils.loadSheet(REPLACEMENT_STYLE_SHEET, win.AGENT_SHEET);
+ win.mozHiddenPluginTouched = true;
+ } catch (e) {
+ Cu.reportError("Error adding plugin replacement style sheet: " + e);
+ }
+ }
+ }
+
+ let plugin = event.target;
+
+ if (eventType == "PluginPlaceholderReplaced") {
+ plugin.removeAttribute("href");
+ let overlay = this.getPluginUI(plugin, "main");
+ this.setVisibility(plugin, overlay, true);
+ let inIDOMUtils = Cc["@mozilla.org/inspector/dom-utils;1"]
+ .getService(Ci.inIDOMUtils);
+ // Add psuedo class so our styling will take effect
+ inIDOMUtils.addPseudoClassLock(plugin, "-moz-handler-clicktoplay");
+ overlay.addEventListener("click", this, true);
+ return;
+ }
+
+ if (!(plugin instanceof Ci.nsIObjectLoadingContent))
+ return;
+
+ if (eventType == "PluginBindingAttached") {
+ // The plugin binding fires this event when it is created.
+ // As an untrusted event, ensure that this object actually has a binding
+ // and make sure we don't handle it twice
+ let overlay = this.getPluginUI(plugin, "main");
+ if (!overlay || overlay._bindingHandled) {
+ return;
+ }
+ overlay._bindingHandled = true;
+
+ // Lookup the handler for this binding
+ eventType = this._getBindingType(plugin);
+ if (!eventType) {
+ // Not all bindings have handlers
+ return;
+ }
+ }
+
+ let shouldShowNotification = false;
+ switch (eventType) {
+ case "PluginCrashed":
+ this.onPluginCrashed(plugin, event);
+ break;
+
+ case "PluginNotFound": {
+ /* NOP */
+ break;
+ }
+
+ case "PluginBlocklisted":
+ case "PluginOutdated":
+ shouldShowNotification = true;
+ break;
+
+ case "PluginVulnerableUpdatable":
+ let updateLink = this.getPluginUI(plugin, "checkForUpdatesLink");
+ let { pluginTag } = this._getPluginInfo(plugin);
+ this.addLinkClickCallback(updateLink, "forwardCallback",
+ "openPluginUpdatePage", pluginTag);
+ /* FALLTHRU */
+
+ case "PluginVulnerableNoUpdate":
+ case "PluginClickToPlay":
+ this._handleClickToPlayEvent(plugin);
+ let pluginName = this._getPluginInfo(plugin).pluginName;
+ let messageString = gNavigatorBundle.formatStringFromName("PluginClickToActivate", [pluginName], 1);
+ let overlayText = this.getPluginUI(plugin, "clickToPlay");
+ overlayText.textContent = messageString;
+ if (eventType == "PluginVulnerableUpdatable" ||
+ eventType == "PluginVulnerableNoUpdate") {
+ let vulnerabilityString = gNavigatorBundle.GetStringFromName(eventType);
+ let vulnerabilityText = this.getPluginUI(plugin, "vulnerabilityStatus");
+ vulnerabilityText.textContent = vulnerabilityString;
+ }
+ shouldShowNotification = true;
+ break;
+
+ case "PluginDisabled":
+ let manageLink = this.getPluginUI(plugin, "managePluginsLink");
+ this.addLinkClickCallback(manageLink, "forwardCallback", "managePlugins");
+ shouldShowNotification = true;
+ break;
+
+ case "PluginInstantiated":
+ let key = this._getPluginInfo(plugin).pluginTag.niceName;
+ Services.telemetry.getKeyedHistogramById("PLUGIN_ACTIVATION_COUNT").add(key);
+ shouldShowNotification = true;
+ let pluginRect = plugin.getBoundingClientRect();
+ if (pluginRect.width <= 5 && pluginRect.height <= 5) {
+ Services.telemetry.getHistogramById("PLUGIN_TINY_CONTENT").add(1);
+ }
+ break;
+ }
+
+ if (this._getPluginInfo(plugin).mimetype === FLASH_MIME_TYPE) {
+ this._recordFlashPluginTelemetry(eventType, plugin);
+ }
+
+ // Show the in-content UI if it's not too big. The crashed plugin handler already did this.
+ let overlay = this.getPluginUI(plugin, "main");
+ if (eventType != "PluginCrashed") {
+ if (overlay != null) {
+ this.setVisibility(plugin, overlay,
+ this.shouldShowOverlay(plugin, overlay));
+ let resizeListener = () => {
+ this.setVisibility(plugin, overlay,
+ this.shouldShowOverlay(plugin, overlay));
+ this.updateNotificationUI();
+ };
+ plugin.addEventListener("overflow", resizeListener);
+ plugin.addEventListener("underflow", resizeListener);
+ }
+ }
+
+ let closeIcon = this.getPluginUI(plugin, "closeIcon");
+ if (closeIcon) {
+ closeIcon.addEventListener("click", clickEvent => {
+ if (clickEvent.button == 0 && clickEvent.isTrusted) {
+ this.hideClickToPlayOverlay(plugin);
+ overlay.setAttribute("dismissed", "true");
+ }
+ }, true);
+ }
+
+ if (shouldShowNotification) {
+ this._showClickToPlayNotification(plugin, false);
+ }
+ },
+
+ _recordFlashPluginTelemetry(eventType, plugin) {
+ if (!Services.telemetry.canRecordExtended) {
+ return;
+ }
+
+ if (!this.flashPluginStats) {
+ this.flashPluginStats = {
+ instancesCount: 0,
+ plugins: new WeakSet()
+ };
+ }
+
+ if (!this.flashPluginStats.plugins.has(plugin)) {
+ // Reporting plugin instance and its dimensions only once.
+ this.flashPluginStats.plugins.add(plugin);
+
+ this.flashPluginStats.instancesCount++;
+
+ let pluginRect = plugin.getBoundingClientRect();
+ Services.telemetry.getHistogramById("FLASH_PLUGIN_WIDTH")
+ .add(pluginRect.width);
+ Services.telemetry.getHistogramById("FLASH_PLUGIN_HEIGHT")
+ .add(pluginRect.height);
+ Services.telemetry.getHistogramById("FLASH_PLUGIN_AREA")
+ .add(pluginRect.width * pluginRect.height);
+
+ let state = this._getPluginInfo(plugin).fallbackType;
+ if (state === null) {
+ state = Ci.nsIObjectLoadingContent.PLUGIN_UNSUPPORTED;
+ }
+ Services.telemetry.getHistogramById("FLASH_PLUGIN_STATES")
+ .add(state);
+ }
+ },
+
+ _finishRecordingFlashPluginTelemetry() {
+ if (this.flashPluginStats) {
+ Services.telemetry.getHistogramById("FLASH_PLUGIN_INSTANCES_ON_PAGE")
+ .add(this.flashPluginStats.instancesCount);
+ delete this.flashPluginStats;
+ }
+ },
+
+ isKnownPlugin(objLoadingContent) {
+ return (objLoadingContent.getContentTypeForMIMEType(objLoadingContent.actualType) ==
+ Ci.nsIObjectLoadingContent.TYPE_PLUGIN);
+ },
+
+ canActivatePlugin(objLoadingContent) {
+ // if this isn't a known plugin, we can't activate it
+ // (this also guards pluginHost.getPermissionStringForType against
+ // unexpected input)
+ if (!this.isKnownPlugin(objLoadingContent))
+ return false;
+
+ let pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ let permissionString = pluginHost.getPermissionStringForType(objLoadingContent.actualType);
+ let principal = objLoadingContent.ownerGlobal.top.document.nodePrincipal;
+ let pluginPermission = Services.perms.testPermissionFromPrincipal(principal, permissionString);
+
+ let isFallbackTypeValid =
+ objLoadingContent.pluginFallbackType >= Ci.nsIObjectLoadingContent.PLUGIN_CLICK_TO_PLAY &&
+ objLoadingContent.pluginFallbackType <= Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_NO_UPDATE;
+
+ return !objLoadingContent.activated &&
+ pluginPermission != Ci.nsIPermissionManager.DENY_ACTION &&
+ isFallbackTypeValid;
+ },
+
+ hideClickToPlayOverlay(plugin) {
+ let overlay = this.getPluginUI(plugin, "main");
+ if (overlay) {
+ overlay.classList.remove("visible");
+ }
+ },
+
+ // Forward a link click callback to the chrome process.
+ forwardCallback(name, pluginTag) {
+ this.global.sendAsyncMessage("PluginContent:LinkClickCallback",
+ { name, pluginTag });
+ },
+
+ submitReport: function submitReport(plugin) {
+ // **STUB**
+ return;
+ },
+
+ reloadPage() {
+ this.global.content.location.reload();
+ },
+
+ // Event listener for click-to-play plugins.
+ _handleClickToPlayEvent(plugin) {
+ let doc = plugin.ownerDocument;
+ let pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ let permissionString;
+ if (plugin instanceof Ci.nsIDOMHTMLAnchorElement) {
+ // We only have replacement content for Flash installs
+ permissionString = pluginHost.getPermissionStringForType(FLASH_MIME_TYPE);
+ } else {
+ let objLoadingContent = plugin.QueryInterface(Ci.nsIObjectLoadingContent);
+ // guard against giving pluginHost.getPermissionStringForType a type
+ // not associated with any known plugin
+ if (!this.isKnownPlugin(objLoadingContent))
+ return;
+ permissionString = pluginHost.getPermissionStringForType(objLoadingContent.actualType);
+ }
+
+ let principal = doc.defaultView.top.document.nodePrincipal;
+ let pluginPermission = Services.perms.testPermissionFromPrincipal(principal, permissionString);
+
+ let overlay = this.getPluginUI(plugin, "main");
+
+ if (pluginPermission == Ci.nsIPermissionManager.DENY_ACTION) {
+ if (overlay) {
+ overlay.classList.remove("visible");
+ }
+ return;
+ }
+
+ if (overlay) {
+ overlay.addEventListener("click", this, true);
+ }
+ },
+
+ onOverlayClick(event) {
+ let document = event.target.ownerDocument;
+ let plugin = document.getBindingParent(event.target);
+ let contentWindow = plugin.ownerGlobal.top;
+ let overlay = this.getPluginUI(plugin, "main");
+ // Have to check that the target is not the link to update the plugin
+ if (!(event.originalTarget instanceof contentWindow.HTMLAnchorElement) &&
+ (event.originalTarget.getAttribute("anonid") != "closeIcon") &&
+ !overlay.hasAttribute("dismissed") &&
+ event.button == 0 &&
+ event.isTrusted) {
+ this._showClickToPlayNotification(plugin, true);
+ event.stopPropagation();
+ event.preventDefault();
+ }
+ },
+
+ reshowClickToPlayNotification() {
+ let contentWindow = this.global.content;
+ let cwu = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ let plugins = cwu.plugins;
+ for (let plugin of plugins) {
+ let overlay = this.getPluginUI(plugin, "main");
+ if (overlay)
+ overlay.removeEventListener("click", this, true);
+ let objLoadingContent = plugin.QueryInterface(Ci.nsIObjectLoadingContent);
+ if (this.canActivatePlugin(objLoadingContent))
+ this._handleClickToPlayEvent(plugin);
+ }
+ this._showClickToPlayNotification(null, false);
+ },
+
+ /**
+ * Activate the plugins that the user has specified.
+ */
+ activatePlugins(pluginInfo, newState) {
+ let contentWindow = this.global.content;
+ let cwu = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ let plugins = cwu.plugins;
+ let pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+
+ let pluginFound = false;
+ let placeHolderFound = false;
+ for (let plugin of plugins) {
+ plugin.QueryInterface(Ci.nsIObjectLoadingContent);
+ if (!this.isKnownPlugin(plugin)) {
+ continue;
+ }
+ if (pluginInfo.permissionString == pluginHost.getPermissionStringForType(plugin.actualType)) {
+ let overlay = this.getPluginUI(plugin, "main");
+ if (plugin instanceof Ci.nsIDOMHTMLAnchorElement) {
+ placeHolderFound = true;
+ } else {
+ pluginFound = true;
+ }
+ if (newState == "block") {
+ if (overlay) {
+ overlay.addEventListener("click", this, true);
+ }
+ plugin.reload(true);
+ } else if (this.canActivatePlugin(plugin)) {
+ if (overlay) {
+ overlay.removeEventListener("click", this, true);
+ }
+ plugin.playPlugin();
+ }
+ }
+ }
+
+ // If there are no instances of the plugin on the page any more, what the
+ // user probably needs is for us to allow and then refresh. Additionally, if
+ // this is content that requires HLS or we replaced the placeholder the page
+ // needs to be refreshed for it to insert its plugins
+ if (newState != "block" &&
+ (!pluginFound || placeHolderFound || contentWindow.pluginRequiresReload)) {
+ this.reloadPage();
+ }
+ this.updateNotificationUI();
+ },
+
+ _showClickToPlayNotification(plugin, showNow) {
+ let plugins = [];
+
+ // If plugin is null, that means the user has navigated back to a page with
+ // plugins, and we need to collect all the plugins.
+ if (plugin === null) {
+ let contentWindow = this.content;
+ let cwu = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ // cwu.plugins may contain non-plugin <object>s, filter them out
+ plugins = cwu.plugins.filter((p) =>
+ p.getContentTypeForMIMEType(p.actualType) == Ci.nsIObjectLoadingContent.TYPE_PLUGIN);
+
+ if (plugins.length == 0) {
+ this.removeNotification("click-to-play-plugins");
+ return;
+ }
+ } else {
+ plugins = [plugin];
+ }
+
+ let pluginData = this.pluginData;
+
+ let principal = this.content.document.nodePrincipal;
+ let location = this.content.document.location.href;
+
+ for (let p of plugins) {
+ let pluginInfo;
+ if (p instanceof Ci.nsIPluginTag) {
+ let mimeType = p.getMimeTypes() > 0 ? p.getMimeTypes()[0] : null;
+ pluginInfo = this._getPluginInfoForTag(p, mimeType);
+ } else {
+ pluginInfo = this._getPluginInfo(p);
+ }
+ if (pluginInfo.permissionString === null) {
+ Cu.reportError("No permission string for active plugin.");
+ continue;
+ }
+ if (pluginData.has(pluginInfo.permissionString)) {
+ continue;
+ }
+
+ let permissionObj = Services.perms.
+ getPermissionObject(principal, pluginInfo.permissionString, false);
+ if (permissionObj) {
+ pluginInfo.pluginPermissionPrePath = permissionObj.principal.originNoSuffix;
+ pluginInfo.pluginPermissionType = permissionObj.expireType;
+ } else {
+ pluginInfo.pluginPermissionPrePath = principal.originNoSuffix;
+ pluginInfo.pluginPermissionType = undefined;
+ }
+
+ this.pluginData.set(pluginInfo.permissionString, pluginInfo);
+ }
+
+ this.haveShownNotification = true;
+
+ this.global.sendAsyncMessage("PluginContent:ShowClickToPlayNotification", {
+ plugins: [...this.pluginData.values()],
+ showNow,
+ location,
+ }, null, principal);
+ },
+
+ /**
+ * Updates the "hidden plugin" notification bar UI.
+ *
+ * @param document (optional)
+ * Specify the document that is causing the update.
+ * This is useful when the document is possibly no longer
+ * the current loaded document (for example, if we're
+ * responding to a PluginRemoved event for an unloading
+ * document). If this parameter is omitted, it defaults
+ * to the current top-level document.
+ */
+ updateNotificationUI(document) {
+ document = document || this.content.document;
+
+ // We're only interested in the top-level document, since that's
+ // the one that provides the Principal that we send back to the
+ // parent.
+ let principal = document.defaultView.top.document.nodePrincipal;
+ let location = document.location.href;
+
+ // Make a copy of the actions from the last popup notification.
+ let haveInsecure = false;
+ let actions = new Map();
+ for (let action of this.pluginData.values()) {
+ switch (action.fallbackType) {
+ // haveInsecure will trigger the red flashing icon and the infobar
+ // styling below
+ case Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_UPDATABLE:
+ case Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_NO_UPDATE:
+ haveInsecure = true;
+ // fall through
+
+ case Ci.nsIObjectLoadingContent.PLUGIN_CLICK_TO_PLAY:
+ actions.set(action.permissionString, action);
+ continue;
+ }
+ }
+
+ // Remove plugins that are already active, or large enough to show an overlay.
+ let cwu = this.content.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ for (let plugin of cwu.plugins) {
+ let info = this._getPluginInfo(plugin);
+ if (!actions.has(info.permissionString)) {
+ continue;
+ }
+ let fallbackType = info.fallbackType;
+ if (fallbackType == Ci.nsIObjectLoadingContent.PLUGIN_ACTIVE) {
+ actions.delete(info.permissionString);
+ if (actions.size == 0) {
+ break;
+ }
+ continue;
+ }
+ if (fallbackType != Ci.nsIObjectLoadingContent.PLUGIN_CLICK_TO_PLAY &&
+ fallbackType != Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_UPDATABLE &&
+ fallbackType != Ci.nsIObjectLoadingContent.PLUGIN_VULNERABLE_NO_UPDATE) {
+ continue;
+ }
+ let overlay = this.getPluginUI(plugin, "main");
+ if (!overlay) {
+ continue;
+ }
+ let shouldShow = this.shouldShowOverlay(plugin, overlay);
+ this.setVisibility(plugin, overlay, shouldShow);
+ if (shouldShow) {
+ actions.delete(info.permissionString);
+ if (actions.size == 0) {
+ break;
+ }
+ }
+ }
+
+ // If there are any items remaining in `actions` now, they are hidden
+ // plugins that need a notification bar.
+ this.global.sendAsyncMessage("PluginContent:UpdateHiddenPluginUI", {
+ haveInsecure,
+ actions: [...actions.values()],
+ location,
+ }, null, principal);
+ },
+
+ removeNotification(name) {
+ this.global.sendAsyncMessage("PluginContent:RemoveNotification", { name });
+ },
+
+ clearPluginCaches() {
+ this.pluginData.clear();
+ this.pluginCrashData.clear();
+ },
+
+ hideNotificationBar(name) {
+ this.global.sendAsyncMessage("PluginContent:HideNotificationBar", { name });
+ },
+
+ /**
+ * Determines whether or not the crashed plugin is contained within current
+ * full screen DOM element.
+ * @param fullScreenElement (DOM element)
+ * The DOM element that is currently full screen, or null.
+ * @param domElement
+ * The DOM element which contains the crashed plugin, or the crashed plugin
+ * itself.
+ * @returns bool
+ * True if the plugin is a descendant of the full screen DOM element, false otherwise.
+ **/
+ isWithinFullScreenElement(fullScreenElement, domElement) {
+
+ /**
+ * Traverses down iframes until it find a non-iframe full screen DOM element.
+ * @param fullScreenIframe
+ * Target iframe to begin searching from.
+ * @returns DOM element
+ * The full screen DOM element contained within the iframe (could be inner iframe), or the original iframe if no inner DOM element is found.
+ **/
+ let getTrueFullScreenElement = fullScreenIframe => {
+ if (typeof fullScreenIframe.contentDocument !== "undefined" && fullScreenIframe.contentDocument.mozFullScreenElement) {
+ return getTrueFullScreenElement(fullScreenIframe.contentDocument.mozFullScreenElement);
+ }
+ return fullScreenIframe;
+ }
+
+ if (fullScreenElement.tagName === "IFRAME") {
+ fullScreenElement = getTrueFullScreenElement(fullScreenElement);
+ }
+
+ if (fullScreenElement.contains(domElement)) {
+ return true;
+ }
+ let parentIframe = domElement.ownerGlobal.frameElement;
+ if (parentIframe) {
+ return this.isWithinFullScreenElement(fullScreenElement, parentIframe);
+ }
+ return false;
+ },
+
+ /**
+ * The PluginCrashed event handler. Note that the PluginCrashed event is
+ * fired for both NPAPI and Goanna Media plugins. In the latter case, the
+ * target of the event is the document that the GMP is being used in.
+ */
+ onPluginCrashed(target, aEvent) {
+ if (!(aEvent instanceof this.content.PluginCrashedEvent))
+ return;
+
+ let fullScreenElement = this.content.document.mozFullScreenElement;
+ if (fullScreenElement) {
+ if (this.isWithinFullScreenElement(fullScreenElement, target)) {
+ this.content.document.mozCancelFullScreen();
+ }
+ }
+
+ if (aEvent.gmpPlugin) {
+ this.GMPCrashed(aEvent);
+ return;
+ }
+
+ if (!(target instanceof Ci.nsIObjectLoadingContent))
+ return;
+
+ let crashData = this.pluginCrashData.get(target.runID);
+ if (!crashData) {
+ // We haven't received information from the parent yet about
+ // this crash, so we should hold off showing the crash report
+ // UI.
+ return;
+ }
+
+ crashData.instances.delete(target);
+ if (crashData.instances.length == 0) {
+ this.pluginCrashData.delete(target.runID);
+ }
+
+ this.setCrashedNPAPIPluginState({
+ plugin: target,
+ state: crashData.state,
+ message: crashData.message,
+ });
+ },
+
+ NPAPIPluginProcessCrashed({pluginName, runID, state}) {
+ let message =
+ gNavigatorBundle.formatStringFromName("crashedpluginsMessage.title",
+ [pluginName], 1);
+
+ let contentWindow = this.global.content;
+ let cwu = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ let plugins = cwu.plugins;
+
+ for (let plugin of plugins) {
+ if (plugin instanceof Ci.nsIObjectLoadingContent &&
+ plugin.runID == runID) {
+ // The parent has told us that the plugin process has died.
+ // It's possible that this content process hasn't yet noticed,
+ // in which case we need to stash this data around until the
+ // PluginCrashed events get sent up.
+ if (plugin.pluginFallbackType == Ci.nsIObjectLoadingContent.PLUGIN_CRASHED) {
+ // This plugin has already been put into the crashed state by the
+ // content process, so we can tweak its crash UI without delay.
+ this.setCrashedNPAPIPluginState({plugin, state, message});
+ } else {
+ // The content process hasn't yet determined that the plugin has crashed.
+ // Stash the data in our map, and throw the plugin into a WeakSet. When
+ // the PluginCrashed event fires on the <object>/<embed>, we'll retrieve
+ // the information we need from the Map and remove the instance from the
+ // WeakSet. Once the WeakSet is empty, we can clear the map.
+ if (!this.pluginCrashData.has(runID)) {
+ this.pluginCrashData.set(runID, {
+ state,
+ message,
+ instances: new WeakSet(),
+ });
+ }
+ let crashData = this.pluginCrashData.get(runID);
+ crashData.instances.add(plugin);
+ }
+ }
+ }
+ },
+
+ setCrashedNPAPIPluginState({plugin, state, message}) {
+ // Force a layout flush so the binding is attached.
+ plugin.clientTop;
+ let overlay = this.getPluginUI(plugin, "main");
+ let statusDiv = this.getPluginUI(plugin, "submitStatus");
+ let optInCB = this.getPluginUI(plugin, "submitURLOptIn");
+
+ this.getPluginUI(plugin, "submitButton")
+ .addEventListener("click", (event) => {
+ if (event.button != 0 || !event.isTrusted)
+ return;
+ this.submitReport(plugin);
+ });
+
+ let pref = Services.prefs.getBranch("dom.ipc.plugins.reportCrashURL");
+ optInCB.checked = pref.getBoolPref("");
+
+ statusDiv.setAttribute("status", state);
+
+ let helpIcon = this.getPluginUI(plugin, "helpIcon");
+ this.addLinkClickCallback(helpIcon, "openHelpPage");
+
+ let crashText = this.getPluginUI(plugin, "crashedText");
+ crashText.textContent = message;
+
+ let link = this.getPluginUI(plugin, "reloadLink");
+ this.addLinkClickCallback(link, "reloadPage");
+
+ let isShowing = this.shouldShowOverlay(plugin, overlay);
+
+ // Is the <object>'s size too small to hold what we want to show?
+ if (!isShowing) {
+ // First try hiding the crash report submission UI.
+ statusDiv.removeAttribute("status");
+
+ isShowing = this.shouldShowOverlay(plugin, overlay);
+ }
+ this.setVisibility(plugin, overlay, isShowing);
+
+ let doc = plugin.ownerDocument;
+ let runID = plugin.runID;
+
+ if (isShowing) {
+ // If a previous plugin on the page was too small and resulted in adding a
+ // notification bar, then remove it because this plugin instance it big
+ // enough to serve as in-content notification.
+ this.hideNotificationBar("plugin-crashed");
+ doc.mozNoPluginCrashedNotification = true;
+
+ // Notify others that the crash reporter UI is now ready.
+ // Currently, this event is only used by tests.
+ let winUtils = this.content.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ let event = new this.content.CustomEvent("PluginCrashReporterDisplayed", {bubbles: true});
+ winUtils.dispatchEventToChromeOnly(plugin, event);
+ } else if (!doc.mozNoPluginCrashedNotification) {
+ // If another plugin on the page was large enough to show our UI, we don't
+ // want to show a notification bar.
+ this.global.sendAsyncMessage("PluginContent:ShowPluginCrashedNotification",
+ { messageString: message, pluginID: runID });
+ // Remove the notification when the page is reloaded.
+ doc.defaultView.top.addEventListener("unload", event => {
+ this.hideNotificationBar("plugin-crashed");
+ });
+ }
+ },
+
+ NPAPIPluginCrashReportSubmitted({ runID, state }) {
+ this.pluginCrashData.delete(runID);
+ let contentWindow = this.global.content;
+ let cwu = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ let plugins = cwu.plugins;
+
+ for (let plugin of plugins) {
+ if (plugin instanceof Ci.nsIObjectLoadingContent &&
+ plugin.runID == runID) {
+ let statusDiv = this.getPluginUI(plugin, "submitStatus");
+ statusDiv.setAttribute("status", state);
+ }
+ }
+ },
+
+ GMPCrashed(aEvent) {
+ let target = aEvent.target;
+ let pluginName = aEvent.pluginName;
+ let gmpPlugin = aEvent.gmpPlugin;
+ let pluginID = aEvent.pluginID;
+ let doc = target.document;
+
+ if (!gmpPlugin || !doc) {
+ // TODO: Throw exception? How did we get here?
+ return;
+ }
+
+ let messageString =
+ gNavigatorBundle.formatStringFromName("crashedpluginsMessage.title",
+ [pluginName], 1);
+
+ this.global.sendAsyncMessage("PluginContent:ShowPluginCrashedNotification",
+ { messageString, pluginID });
+
+ // Remove the notification when the page is reloaded.
+ doc.defaultView.top.addEventListener("unload", event => {
+ this.hideNotificationBar("plugin-crashed");
+ });
+ },
+};