summaryrefslogtreecommitdiffstats
path: root/dom/plugins/test/unit
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/plugins/test/unit
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/plugins/test/unit')
-rw-r--r--dom/plugins/test/unit/head_plugins.js195
-rw-r--r--dom/plugins/test/unit/test_allowed_types.js142
-rw-r--r--dom/plugins/test/unit/test_bug471245.js23
-rw-r--r--dom/plugins/test/unit/test_bug813245.js87
-rw-r--r--dom/plugins/test/unit/test_bug854467.js40
-rw-r--r--dom/plugins/test/unit/test_nice_plugin_name.js80
-rw-r--r--dom/plugins/test/unit/test_persist_in_prefs.js76
-rw-r--r--dom/plugins/test/unit/test_plugin_default_state.js31
-rw-r--r--dom/plugins/test/unit/test_plugin_default_state_xpi.js118
-rw-r--r--dom/plugins/test/unit/xpcshell.ini29
10 files changed, 821 insertions, 0 deletions
diff --git a/dom/plugins/test/unit/head_plugins.js b/dom/plugins/test/unit/head_plugins.js
new file mode 100644
index 000000000..4d32a52bf
--- /dev/null
+++ b/dom/plugins/test/unit/head_plugins.js
@@ -0,0 +1,195 @@
+/* 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/.
+ */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+
+const gIsWindows = mozinfo.os == "win";
+const gIsOSX = mozinfo.os == "mac";
+const gIsLinux = mozinfo.os == "linux";
+const gDirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties);
+
+function allow_all_plugins() {
+ Services.prefs.setBoolPref("plugin.load_flash_only", false);
+}
+
+// Finds the test plugin library
+function get_test_plugin(secondplugin=false) {
+ var pluginEnum = gDirSvc.get("APluginsDL", Ci.nsISimpleEnumerator);
+ while (pluginEnum.hasMoreElements()) {
+ let dir = pluginEnum.getNext().QueryInterface(Ci.nsILocalFile);
+ let name = get_platform_specific_plugin_name(secondplugin);
+ let plugin = dir.clone();
+ plugin.append(name);
+ if (plugin.exists()) {
+ plugin.normalize();
+ return plugin;
+ }
+ }
+ return null;
+}
+
+// Finds the test nsIPluginTag
+function get_test_plugintag(aName="Test Plug-in") {
+ const Cc = Components.classes;
+ const Ci = Components.interfaces;
+
+ var name = aName || "Test Plug-in";
+ var host = Cc["@mozilla.org/plugin/host;1"].
+ getService(Ci.nsIPluginHost);
+ var tags = host.getPluginTags();
+
+ for (var i = 0; i < tags.length; i++) {
+ if (tags[i].name == name)
+ return tags[i];
+ }
+ return null;
+}
+
+// Creates a fake ProfDS directory key, copied from do_get_profile
+function do_get_profile_startup() {
+ let env = Components.classes["@mozilla.org/process/environment;1"]
+ .getService(Components.interfaces.nsIEnvironment);
+ // the python harness sets this in the environment for us
+ let profd = env.get("XPCSHELL_TEST_PROFILE_DIR");
+ let file = Components.classes["@mozilla.org/file/local;1"]
+ .createInstance(Components.interfaces.nsILocalFile);
+ file.initWithPath(profd);
+
+ let dirSvc = Components.classes["@mozilla.org/file/directory_service;1"]
+ .getService(Components.interfaces.nsIProperties);
+ let provider = {
+ getFile: function(prop, persistent) {
+ persistent.value = true;
+ if (prop == "ProfDS") {
+ return file.clone();
+ }
+ throw Components.results.NS_ERROR_FAILURE;
+ },
+ QueryInterface: function(iid) {
+ if (iid.equals(Components.interfaces.nsIDirectoryServiceProvider) ||
+ iid.equals(Components.interfaces.nsISupports)) {
+ return this;
+ }
+ throw Components.results.NS_ERROR_NO_INTERFACE;
+ }
+ };
+ dirSvc.QueryInterface(Components.interfaces.nsIDirectoryService)
+ .registerProvider(provider);
+ return file.clone();
+}
+
+function get_platform_specific_plugin_name(secondplugin=false) {
+ if (secondplugin) {
+ if (gIsWindows) return "npsecondtest.dll";
+ if (gIsOSX) return "SecondTest.plugin";
+ if (gIsLinux) return "libnpsecondtest.so";
+ } else {
+ if (gIsWindows) return "nptest.dll";
+ if (gIsOSX) return "Test.plugin";
+ if (gIsLinux) return "libnptest.so";
+ }
+ return null;
+}
+
+function get_platform_specific_plugin_suffix() {
+ if (gIsWindows) return ".dll";
+ else if (gIsOSX) return ".plugin";
+ else if (gIsLinux) return ".so";
+ else return null;
+}
+
+function get_test_plugin_no_symlink() {
+ let dirSvc = Cc["@mozilla.org/file/directory_service;1"]
+ .getService(Ci.nsIProperties);
+ let pluginEnum = dirSvc.get("APluginsDL", Ci.nsISimpleEnumerator);
+ while (pluginEnum.hasMoreElements()) {
+ let dir = pluginEnum.getNext().QueryInterface(Ci.nsILocalFile);
+ let plugin = dir.clone();
+ plugin.append(get_platform_specific_plugin_name());
+ if (plugin.exists()) {
+ return plugin;
+ }
+ }
+ return null;
+}
+
+var gGlobalScope = this;
+function loadAddonManager() {
+ let ns = {};
+ Cu.import("resource://gre/modules/Services.jsm", ns);
+ let head = "../../../../toolkit/mozapps/extensions/test/xpcshell/head_addons.js";
+ let file = do_get_file(head);
+ let uri = ns.Services.io.newFileURI(file);
+ ns.Services.scriptloader.loadSubScript(uri.spec, gGlobalScope);
+ createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
+ startupManager();
+}
+
+// Install addon and return a Promise<boolean> that is
+// resolve with true on success, false otherwise.
+function installAddon(relativePath) {
+ let deferred = Promise.defer();
+ let success = () => deferred.resolve(true);
+ let fail = () => deferred.resolve(false);
+ let listener = {
+ onDownloadCancelled: fail,
+ onDownloadFailed: fail,
+ onInstallCancelled: fail,
+ onInstallFailed: fail,
+ onInstallEnded: success,
+ };
+
+ let installCallback = install => {
+ install.addListener(listener);
+ install.install();
+ };
+
+ let file = do_get_file(relativePath, false);
+ AddonManager.getInstallForFile(file, installCallback,
+ "application/x-xpinstall");
+
+ return deferred.promise;
+}
+
+// Uninstall addon and return a Promise<boolean> that is
+// resolve with true on success, false otherwise.
+function uninstallAddon(id) {
+ let deferred = Promise.defer();
+
+ AddonManager.getAddonByID(id, addon => {
+ if (!addon) {
+ deferred.resolve(false);
+ }
+
+ let listener = {};
+ let handler = addon => {
+ if (addon.id !== id) {
+ return;
+ }
+
+ AddonManager.removeAddonListener(listener);
+ deferred.resolve(true);
+ };
+
+ listener.onUninstalled = handler;
+ listener.onDisabled = handler;
+
+ AddonManager.addAddonListener(listener);
+ addon.uninstall();
+ });
+
+ return deferred.promise;
+}
+
+// Returns a Promise<Addon> that is resolved with
+// the corresponding addon or rejected.
+function getAddonByID(id) {
+ let deferred = Promise.defer();
+ AddonManager.getAddonByID(id, addon => deferred.resolve(addon));
+ return deferred.promise;
+}
diff --git a/dom/plugins/test/unit/test_allowed_types.js b/dom/plugins/test/unit/test_allowed_types.js
new file mode 100644
index 000000000..09b30b31a
--- /dev/null
+++ b/dom/plugins/test/unit/test_allowed_types.js
@@ -0,0 +1,142 @@
+/* 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/.
+ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+function run_test() {
+ const pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ const pluginDefaultState = Services.prefs.getIntPref("plugin.default.state");
+
+ Services.prefs.setBoolPref("plugin.load_flash_only", false);
+
+ function reload_plugins_with_allowed_types(allowed_types) {
+ if (typeof allowed_types === "undefined") {
+ // If we didn't get an allowed_types string, then unset the pref,
+ // so the caller can test the behavior when the pref isn't set.
+ Services.prefs.clearUserPref("plugin.allowed_types");
+ } else {
+ Services.prefs.setCharPref("plugin.allowed_types", allowed_types);
+ }
+ pluginHost.reloadPlugins();
+ }
+
+ function get_status_for_type(type) {
+ try {
+ return pluginHost.getStateForType(type);
+ } catch(ex) {
+ // If the type is not allowed, then nsIPluginHost.getStateForType throws
+ // NS_ERROR_NOT_AVAILABLE, for which we return undefined to make it easier
+ // to write assertions about the API.
+ if (ex.result === Cr.NS_ERROR_NOT_AVAILABLE) {
+ return undefined;
+ }
+ throw ex;
+ }
+ }
+
+ // If allowed_types isn't set, then all plugin types are enabled.
+ reload_plugins_with_allowed_types();
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ // If allowed_types is set to the empty string, then all plugin types are enabled.
+ reload_plugins_with_allowed_types("");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ // If allowed_types is set to anything other than the empty string,
+ // then only types that exactly match its comma-separated entries are enabled,
+ // so a single space disables all types.
+ reload_plugins_with_allowed_types(" ");
+ do_check_eq(get_status_for_type("application/x-test"), undefined);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), undefined);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ // The rest of the assertions test various values of allowed_types to ensure
+ // that the correct types are enabled.
+
+ reload_plugins_with_allowed_types("application/x-test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), undefined);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-Second-Test");
+ do_check_eq(get_status_for_type("application/x-test"), undefined);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-nonexistent");
+ do_check_eq(get_status_for_type("application/x-test"), undefined);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), undefined);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-test,application/x-Second-Test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-Second-Test,application/x-test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-test,application/x-nonexistent");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), undefined);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-nonexistent,application/x-test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), undefined);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-test,application/x-Second-Test,application/x-nonexistent");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-test,application/x-nonexistent,application/x-Second-Test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-Second-Test,application/x-test,application/x-nonexistent");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-Second-Test,application/x-nonexistent,application/x-test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-nonexistent,application/x-test,application/x-Second-Test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ reload_plugins_with_allowed_types("application/x-nonexistent,application/x-Second-Test,application/x-test");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState);
+ do_check_eq(get_status_for_type("application/x-nonexistent"), undefined);
+
+ // Plugin types are case-insensitive, so matching should be too.
+ reload_plugins_with_allowed_types("APPLICATION/X-TEST");
+ do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState);
+ reload_plugins_with_allowed_types("application/x-test");
+ do_check_eq(get_status_for_type("APPLICATION/X-TEST"), pluginDefaultState);
+
+ // Types must match exactly, so supersets should not enable subset types.
+ reload_plugins_with_allowed_types("application/x-test-superset");
+ do_check_eq(get_status_for_type("application/x-test"), undefined);
+ reload_plugins_with_allowed_types("superset-application/x-test");
+ do_check_eq(get_status_for_type("application/x-test"), undefined);
+
+ // Clean up.
+ Services.prefs.clearUserPref("plugin.allowed_types");
+ Services.prefs.clearUserPref("plugin.importedState");
+}
diff --git a/dom/plugins/test/unit/test_bug471245.js b/dom/plugins/test/unit/test_bug471245.js
new file mode 100644
index 000000000..8e38afcdc
--- /dev/null
+++ b/dom/plugins/test/unit/test_bug471245.js
@@ -0,0 +1,23 @@
+/* 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/.
+ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+function run_test() {
+ allow_all_plugins();
+ do_get_profile_startup();
+
+ var plugin = get_test_plugintag();
+ do_check_true(plugin == null);
+
+ // Initialises a profile folder
+ do_get_profile();
+
+ var plugin = get_test_plugintag();
+ do_check_false(plugin == null);
+
+ // Clean up
+ Services.prefs.clearUserPref("plugin.importedState");
+}
diff --git a/dom/plugins/test/unit/test_bug813245.js b/dom/plugins/test/unit/test_bug813245.js
new file mode 100644
index 000000000..069e4a014
--- /dev/null
+++ b/dom/plugins/test/unit/test_bug813245.js
@@ -0,0 +1,87 @@
+/* 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/.
+ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+// Plugin registry uses different field delimeters on different platforms
+var DELIM = mozinfo.os == "win" ? "|" : ":";
+
+var gProfD = do_get_profile_startup();
+
+// Writes out some plugin registry to the profile
+function write_registry(version, info) {
+ let runtime = Cc["@mozilla.org/xre/runtime;1"].getService(Ci.nsIXULRuntime);
+
+ var header = "Generated File. Do not edit.\n\n";
+ header += "[HEADER]\n";
+ header += "Version" + DELIM + version + DELIM + "$\n";
+ header += "Arch" + DELIM + runtime.XPCOMABI + DELIM + "$\n";
+ header += "\n";
+ header += "[PLUGINS]\n";
+
+ var registry = gProfD.clone();
+ registry.append("pluginreg.dat");
+ var foStream = Components.classes["@mozilla.org/network/file-output-stream;1"]
+ .createInstance(Components.interfaces.nsIFileOutputStream);
+ // write, create, truncate
+ foStream.init(registry, 0x02 | 0x08 | 0x20, 0o666, 0);
+
+ var charset = "UTF-8"; // Can be any character encoding name that Mozilla supports
+ var os = Cc["@mozilla.org/intl/converter-output-stream;1"].
+ createInstance(Ci.nsIConverterOutputStream);
+ os.init(foStream, charset, 0, 0x0000);
+
+ os.writeString(header);
+ os.writeString(info);
+ os.close();
+}
+
+function run_test() {
+ allow_all_plugins();
+ var plugin = get_test_plugintag();
+ do_check_true(plugin == null);
+
+ var file = get_test_plugin();
+ if (!file) {
+ do_throw("Plugin library not found");
+ }
+
+ // write plugin registry data
+ let registry = "";
+
+ if (gIsOSX) {
+ registry += file.leafName + DELIM + "$\n";
+ registry += file.path + DELIM + "$\n";
+ } else {
+ registry += file.path + DELIM + "$\n";
+ registry += DELIM + "$\n";
+ }
+ registry += "0.0.0.0" + DELIM + "$\n";
+ registry += "16725225600" + DELIM + "0" + DELIM + "5" + DELIM + "$\n";
+ registry += "Plug-in for testing purposes." + DELIM + "$\n";
+ registry += "Test Plug-in" + DELIM + "$\n";
+ registry += "999999999999999999999999999999999999999999999999|0|5|$\n";
+ registry += "0" + DELIM + "application/x-test" + DELIM + "Test mimetype" +
+ DELIM + "tst" + DELIM + "$\n";
+
+ registry += "\n";
+ registry += "[INVALID]\n";
+ registry += "\n";
+ write_registry("0.15", registry);
+
+ // Initialise profile folder
+ do_get_profile();
+
+ var plugin = get_test_plugintag();
+ if (!plugin)
+ do_throw("Plugin tag not found");
+
+ // The plugin registry should have been rejected.
+ // If not, the test plugin version would be 0.0.0.0
+ do_check_eq(plugin.version, "1.0.0.0");
+
+ // Clean up
+ Services.prefs.clearUserPref("plugin.importedState");
+}
diff --git a/dom/plugins/test/unit/test_bug854467.js b/dom/plugins/test/unit/test_bug854467.js
new file mode 100644
index 000000000..0487dffc6
--- /dev/null
+++ b/dom/plugins/test/unit/test_bug854467.js
@@ -0,0 +1,40 @@
+/* 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/.
+ */
+
+function check_state(aTag, aExpectedClicktoplay, aExpectedDisabled) {
+ do_check_eq(aTag.clicktoplay, aExpectedClicktoplay);
+ do_check_eq(aTag.disabled, aExpectedDisabled);
+}
+
+function run_test() {
+ allow_all_plugins();
+ let tag = get_test_plugintag();
+ tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED;
+ check_state(tag, false, false);
+
+ /* test going to click-to-play from always enabled and back */
+ tag.enabledState = Ci.nsIPluginTag.STATE_CLICKTOPLAY;
+ check_state(tag, true, false);
+ tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED;
+ check_state(tag, false, false);
+
+ /* test going to disabled from always enabled and back */
+ tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED;
+ check_state(tag, false, true);
+ tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED;
+ check_state(tag, false, false);
+
+ /* test going to click-to-play from disabled and back */
+ tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED;
+ check_state(tag, false, true);
+ tag.enabledState = Ci.nsIPluginTag.STATE_CLICKTOPLAY;
+ check_state(tag, true, false);
+ tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED;
+ check_state(tag, false, true);
+
+ /* put everything back to normal and check that that succeeded */
+ tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED;
+ check_state(tag, false, false);
+}
diff --git a/dom/plugins/test/unit/test_nice_plugin_name.js b/dom/plugins/test/unit/test_nice_plugin_name.js
new file mode 100644
index 000000000..32d2870af
--- /dev/null
+++ b/dom/plugins/test/unit/test_nice_plugin_name.js
@@ -0,0 +1,80 @@
+/* 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 XULAPPINFO_CONTRACTID = "@mozilla.org/xre/app-info;1";
+const XULAPPINFO_CID = Components.ID("{c763b610-9d49-455a-bbd2-ede71682a1ac}");
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+var gAppInfo = null;
+
+function createAppInfo(ID, name, version, platformVersion="1.0") {
+ let tmp = {};
+ Cu.import("resource://testing-common/AppInfo.jsm", tmp);
+ tmp.updateAppInfo({
+ ID, name, version, platformVersion,
+ crashReporter: true
+ });
+ gAppInfo = tmp.getAppInfo();
+}
+
+var gPluginHost = null;
+
+function test_expected_permission_string(aPermString) {
+ gPluginHost.reloadPlugins(false);
+ let plugin = get_test_plugintag();
+ do_check_false(plugin == null);
+ do_check_eq(gPluginHost.getPermissionStringForType("application/x-test"),
+ aPermString);
+}
+
+function run_test() {
+ allow_all_plugins();
+ do_check_true(gIsWindows || gIsOSX || gIsLinux);
+ do_check_true(!(gIsWindows && gIsOSX) && !(gIsWindows && gIsLinux) &&
+ !(gIsOSX && gIsLinux));
+
+ createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9");
+ gPluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+
+ let expectedDefaultPermissionString = null;
+ if (gIsWindows) expectedDefaultPermissionString = "plugin:nptest";
+ if (gIsOSX) expectedDefaultPermissionString = "plugin:test";
+ if (gIsLinux) expectedDefaultPermissionString = "plugin:libnptest";
+ test_expected_permission_string(expectedDefaultPermissionString);
+
+ let suffix = get_platform_specific_plugin_suffix();
+ let pluginFile = get_test_plugin_no_symlink();
+ let pluginDir = pluginFile.parent;
+ pluginFile.copyTo(null, "npblah235" + suffix);
+ let pluginCopy = pluginDir.clone();
+ pluginCopy.append("npblah235" + suffix);
+ let tempDir = do_get_tempdir();
+ pluginFile.moveTo(tempDir, null);
+ test_expected_permission_string("plugin:npblah");
+
+ pluginCopy.moveTo(null, "npasdf-3.2.2" + suffix);
+ test_expected_permission_string("plugin:npasdf");
+
+ pluginCopy.moveTo(null, "npasdf_##29387!{}{[][" + suffix);
+ test_expected_permission_string("plugin:npasdf");
+
+ pluginCopy.moveTo(null, "npqtplugin7" + suffix);
+ test_expected_permission_string("plugin:npqtplugin");
+
+ pluginCopy.moveTo(null, "npFoo3d" + suffix);
+ test_expected_permission_string("plugin:npfoo3d");
+
+ pluginCopy.moveTo(null, "NPSWF32_11_5_502_146" + suffix);
+ test_expected_permission_string("plugin:npswf");
+
+ pluginCopy.remove(true);
+ pluginFile.moveTo(pluginDir, null);
+ test_expected_permission_string(expectedDefaultPermissionString);
+
+ // Clean up
+ Services.prefs.clearUserPref("plugin.importedState");
+}
diff --git a/dom/plugins/test/unit/test_persist_in_prefs.js b/dom/plugins/test/unit/test_persist_in_prefs.js
new file mode 100644
index 000000000..ede0074d3
--- /dev/null
+++ b/dom/plugins/test/unit/test_persist_in_prefs.js
@@ -0,0 +1,76 @@
+/* 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/.
+ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+// Plugin registry uses different field delimeters on different platforms
+var DELIM = mozinfo.os == "win" ? "|" : ":";
+
+var gProfD = do_get_profile_startup();
+
+function run_test() {
+ allow_all_plugins();
+
+ do_check_true(gIsWindows || gIsOSX || gIsLinux);
+
+ let file = get_test_plugin_no_symlink();
+ if (!file)
+ do_throw("Plugin library not found");
+
+ const pluginDir = file.parent;
+ const tempDir = do_get_tempdir();
+ const suffix = get_platform_specific_plugin_suffix();
+ const pluginName = file.leafName.substring(0, file.leafName.length - suffix.length).toLowerCase();
+ const pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ const statePref = "plugin.state." + pluginName;
+
+ // Initialise profile folder
+ do_get_profile();
+
+ let plugin = get_test_plugintag();
+ if (!plugin)
+ do_throw("Plugin tag not found");
+
+ plugin.enabledState = Ci.nsIPluginTag.STATE_DISABLED;
+
+ // prepare a copy of the plugin and backup the original
+ file.copyTo(null, "nptestcopy" + suffix);
+ let copy = pluginDir.clone();
+ copy.append("nptestcopy" + suffix);
+ file.moveTo(tempDir, null);
+
+ // test that the settings persist through a few variations of test-plugin names
+ let testNames = [
+ pluginName + "2",
+ pluginName.toUpperCase() + "_11_5_42_2323",
+ pluginName + "-5.2.7"
+ ];
+ testNames.forEach(function(leafName) {
+ dump("Checking " + leafName + ".\n");
+ copy.moveTo(null, leafName + suffix);
+ pluginHost.reloadPlugins(false);
+ plugin = get_test_plugintag();
+ do_check_false(plugin == null);
+ do_check_true(plugin.disabled);
+ do_check_false(plugin.clicktoplay);
+ });
+
+ // check that the state persists even if the plugin is not always present
+ copy.moveTo(tempDir, null);
+ pluginHost.reloadPlugins(false);
+ copy.moveTo(pluginDir, null);
+ pluginHost.reloadPlugins(false);
+
+ plugin = get_test_plugintag();
+ do_check_false(plugin == null);
+ do_check_true(plugin.disabled);
+ do_check_false(plugin.clicktoplay);
+
+ // clean up
+ Services.prefs.clearUserPref(statePref);
+ Services.prefs.clearUserPref("plugin.importedState");
+ copy.remove(true);
+ file.moveTo(pluginDir, null);
+}
diff --git a/dom/plugins/test/unit/test_plugin_default_state.js b/dom/plugins/test/unit/test_plugin_default_state.js
new file mode 100644
index 000000000..cb68c61e7
--- /dev/null
+++ b/dom/plugins/test/unit/test_plugin_default_state.js
@@ -0,0 +1,31 @@
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+function run_test() {
+ allow_all_plugins();
+ let pluginDefaultState = Services.prefs.getIntPref("plugin.default.state");
+ // if this fails, we just have to switch around the values we're testing
+ do_check_neq(pluginDefaultState, Ci.nsIPluginTag.STATE_DISABLED);
+ let nonDefaultState = (pluginDefaultState != Ci.nsIPluginTag.STATE_ENABLED ?
+ Ci.nsIPluginTag.STATE_ENABLED :
+ Ci.nsIPluginTag.STATE_CLICKTOPLAY);
+ let ph = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+ let testPlugin = get_test_plugintag();
+ // the test plugin should have the default enabledState
+ do_check_eq(testPlugin.enabledState, pluginDefaultState);
+
+ let secondTestPlugin = get_test_plugintag("Second Test Plug-in");
+ // set an enabledState for the second test plugin
+ secondTestPlugin.enabledState = Ci.nsIPluginTag.STATE_DISABLED;
+ // change what the default enabledState is
+ Services.prefs.setIntPref("plugin.default.state", nonDefaultState);
+ // the test plugin should follow the default (it has no individual pref yet)
+ do_check_eq(testPlugin.enabledState, nonDefaultState);
+ // the second test plugin should retain its preferred state
+ do_check_eq(secondTestPlugin.enabledState, Ci.nsIPluginTag.STATE_DISABLED);
+
+ // clean up
+ testPlugin.enabledState = pluginDefaultState;
+ secondTestPlugin.enabledState = pluginDefaultState;
+ Services.prefs.clearUserPref("plugin.default.state");
+ Services.prefs.clearUserPref("plugin.importedState");
+}
diff --git a/dom/plugins/test/unit/test_plugin_default_state_xpi.js b/dom/plugins/test/unit/test_plugin_default_state_xpi.js
new file mode 100644
index 000000000..f1aeb3ac9
--- /dev/null
+++ b/dom/plugins/test/unit/test_plugin_default_state_xpi.js
@@ -0,0 +1,118 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Promise.jsm");
+
+const ADDON_ID = "test-plugin-from-xpi@tests.mozilla.org";
+const XRE_EXTENSIONS_DIR_LIST = "XREExtDL";
+const NS_APP_PLUGINS_DIR_LIST = "APluginsDL";
+
+const gPluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
+const gXPCOMABI = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime).XPCOMABI;
+var gProfileDir = null;
+
+function getAddonRoot(profileDir, id) {
+ let dir = profileDir.clone();
+ dir.append("extensions");
+ Assert.ok(dir.exists(), "Extensions dir should exist: " + dir.path);
+ dir.append(id);
+ return dir;
+}
+
+function getTestaddonFilename() {
+ let abiPart = "";
+ if (gIsOSX) {
+ abiPart = "_" + gXPCOMABI;
+ }
+ return "testaddon" + abiPart + ".xpi";
+}
+
+function run_test() {
+ allow_all_plugins();
+ loadAddonManager();
+ gProfileDir = do_get_profile();
+ do_register_cleanup(() => shutdownManager());
+ run_next_test();
+}
+
+add_task(function* test_state() {
+ // Remove test so we will have only one "Test Plug-in" registered.
+ // xpcshell tests have plugins in per-test profiles, so that's fine.
+ let file = get_test_plugin();
+ file.remove(true);
+ file = get_test_plugin(true);
+ file.remove(true);
+
+ Services.prefs.setIntPref("plugin.default.state", Ci.nsIPluginTag.STATE_CLICKTOPLAY);
+ Services.prefs.setIntPref("plugin.defaultXpi.state", Ci.nsIPluginTag.STATE_ENABLED);
+
+ let success = yield installAddon(getTestaddonFilename());
+ Assert.ok(success, "Should have installed addon.");
+ let addonDir = getAddonRoot(gProfileDir, ADDON_ID);
+
+ let provider = {
+ classID: Components.ID("{0af6b2d7-a06c-49b7-babc-636d292b0dbb}"),
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsIDirectoryServiceProvider,
+ Ci.nsIDirectoryServiceProvider2]),
+
+ getFile: function (prop, persistant) {
+ throw Cr.NS_ERROR_FAILURE;
+ },
+
+ getFiles: function (prop) {
+ let result = [];
+
+ switch (prop) {
+ case XRE_EXTENSIONS_DIR_LIST:
+ result.push(addonDir);
+ break;
+ case NS_APP_PLUGINS_DIR_LIST:
+ let pluginDir = addonDir.clone();
+ pluginDir.append("plugins");
+ result.push(pluginDir);
+ break;
+ default:
+ throw Cr.NS_ERROR_FAILURE;
+ }
+
+ return {
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsISimpleEnumerator]),
+ hasMoreElements: () => result.length > 0,
+ getNext: () => result.shift(),
+ };
+ },
+ };
+
+ let dirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties);
+ dirSvc.QueryInterface(Ci.nsIDirectoryService).registerProvider(provider);
+
+ // We installed a non-restartless addon, need to restart the manager.
+ restartManager();
+ gPluginHost.reloadPlugins();
+
+ Assert.ok(addonDir.exists(), "Addon path should exist: " + addonDir.path);
+ Assert.ok(addonDir.isDirectory(), "Addon path should be a directory: " + addonDir.path);
+ let pluginDir = addonDir.clone();
+ pluginDir.append("plugins");
+ Assert.ok(pluginDir.exists(), "Addon plugins path should exist: " + pluginDir.path);
+ Assert.ok(pluginDir.isDirectory(), "Addon plugins path should be a directory: " + pluginDir.path);
+
+ let addon = yield getAddonByID(ADDON_ID);
+ Assert.ok(!addon.appDisabled, "Addon should not be appDisabled");
+ Assert.ok(addon.isActive, "Addon should be active");
+ Assert.ok(addon.isCompatible, "Addon should be compatible");
+ Assert.ok(!addon.userDisabled, "Addon should not be user disabled");
+
+ let testPlugin = get_test_plugintag();
+ Assert.notEqual(testPlugin, null, "Test plugin should have been found");
+ Assert.equal(testPlugin.enabledState, Ci.nsIPluginTag.STATE_ENABLED, "Test plugin from addon should have state enabled");
+
+ pluginDir.append(testPlugin.filename);
+ Assert.ok(pluginDir.exists(), "Plugin file should exist in addon directory: " + pluginDir.path);
+
+ testPlugin = get_test_plugintag("Second Test Plug-in");
+ Assert.notEqual(testPlugin, null, "Second test plugin should have been found");
+ Assert.equal(testPlugin.enabledState, Ci.nsIPluginTag.STATE_ENABLED, "Second test plugin from addon should have state enabled");
+});
diff --git a/dom/plugins/test/unit/xpcshell.ini b/dom/plugins/test/unit/xpcshell.ini
new file mode 100644
index 000000000..8dae66b20
--- /dev/null
+++ b/dom/plugins/test/unit/xpcshell.ini
@@ -0,0 +1,29 @@
+[DEFAULT]
+skip-if = toolkit == 'android'
+head = head_plugins.js
+tail =
+tags = addons
+firefox-appdir = browser
+support-files =
+ !/toolkit/mozapps/extensions/test/xpcshell/head_addons.js
+
+[test_allowed_types.js]
+skip-if = appname == "thunderbird"
+reason = plugins are disabled by default in Thunderbird
+[test_bug471245.js]
+# Bug 676953: test fails consistently on Android
+fail-if = os == "android"
+[test_bug813245.js]
+# Bug 676953: test fails consistently on Android
+fail-if = os == "android"
+[test_nice_plugin_name.js]
+# Bug 676953: test fails consistently on Android
+fail-if = os == "android"
+[test_persist_in_prefs.js]
+skip-if = appname == "thunderbird"
+reason = plugins are disabled by default in Thunderbird
+[test_bug854467.js]
+[test_plugin_default_state.js]
+skip-if = appname == "thunderbird"
+reason = plugins are disabled by default in Thunderbird
+[test_plugin_default_state_xpi.js]