The Tor Browser: comparison content/base/test/test

--1:000000000000
+:c256d1465108
+<!DOCTYPE html>
+<html>
+<head>
+<title>Plugin instantiation</title>
+<script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+<script type="application/javascript" src="/tests/SimpleTest/SpecialPowers.js"></script>
+<meta charset="utf-8">
+<body onload="onLoad()">
+<script class="testbody" type="text/javascript;version=1.8">
+"use strict";
+SimpleTest.waitForExplicitFinish();
+var pluginHost = SpecialPowers.Cc["@mozilla.org/plugin/host;1"]
+.getService(SpecialPowers.Ci.nsIPluginHost);
+var pluginTags = pluginHost.getPluginTags();
+for (var tag of pluginTags) {
+if (tag.name == "Test Plug-in") {
+tag.enabledState = SpecialPowers.Ci.nsIPluginTag.STATE_ENABLED;;
+}
+}
+// This can go away once embed also is on WebIDL
+let OBJLC = SpecialPowers.Ci.nsIObjectLoadingContent;
+// Use string modes in this test to make the test easier to read/debug.
+// nsIObjectLoadingContent refers to this as "type", but I am using "mode"
+// in the test to avoid confusing with content-type.
+let prettyModes = {};
+prettyModes[OBJLC.TYPE_LOADING] = "loading";
+prettyModes[OBJLC.TYPE_IMAGE] = "image";
+prettyModes[OBJLC.TYPE_PLUGIN] = "plugin";
+prettyModes[OBJLC.TYPE_DOCUMENT] = "document";
+prettyModes[OBJLC.TYPE_NULL] = "none";
+let body = document.body;
+// A single-pixel white png
+let testPNG = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3AoIFiETNqbNRQAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAACklEQVQIHWP4DwABAQEANl9ngAAAAABJRU5ErkJggg==';
+// An empty, but valid, SVG
+let testSVG = 'data:image/svg+xml,<?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"></svg>';
+// executeSoon wrapper to count pending callbacks
+let pendingCalls = 0;
+let afterPendingCalls = false;
+function runWhenDone(func) {
+if (!pendingCalls)
+func();
+else
+afterPendingCalls = func;
+}
+function runSoon(func) {
+pendingCalls++;
+SimpleTest.executeSoon(function() {
+func();
+if (--pendingCalls < 1 && afterPendingCalls)
+afterPendingCalls();
+});
+}
+function src(obj, state, uri) {
+// If we have a running plugin, src changing should always throw it out,
+// even if it causes us to load the same plugin again.
+if (uri && runningPlugin(obj, state)) {
+if (!state.oldPlugins)
+state.oldPlugins = [];
+try {
+state.oldPlugins.push(obj.getObjectValue());
+} catch (e) {
+ok(false, "Running plugin but cannot call getObjectValue?");
+}
+}
+var srcattr;
+if (state.tagName == "object")
+srcattr = "data";
+else if (state.tagName == "embed")
+srcattr = "src";
+else
+ok(false, "Internal test fail: Why are we setting the src of an applet");
+// Plugins should always go away immediately on src/data change
+state.initialPlugin = false;
+if (uri === null) {
+removeAttr(obj, srcattr);
+// TODO Bug 767631 - we don't trigger loadObject on UnsetAttr :(
+forceReload(obj, state);
+} else {
+setAttr(obj, srcattr, uri);
+}
+}
+// We have to be careful not to reach past the nsObjectLoadingContent
+// prototype to touch generic element attributes, as this will try to
+// spawn the plugin, breaking our ability to test for that.
+function getAttr(obj, attr) {
+return document.body.constructor.prototype.getAttribute.call(obj, attr);
+}
+function setAttr(obj, attr, val) {
+return document.body.constructor.prototype.setAttribute.call(obj, attr, val);
+}
+function hasAttr(obj, attr) {
+return document.body.constructor.prototype.hasAttribute.call(obj, attr);
+}
+function removeAttr(obj, attr) {
+return document.body.constructor.prototype.removeAttribute.call(obj, attr);
+}
+function setDisplayed(obj, display) {
+if (display)
+removeAttr(obj, 'style');
+else
+setAttr(obj, 'style', "display: none;");
+}
+function displayed(obj) {
+// Hacky, but that's all we use style for.
+return !hasAttr(obj, 'style');
+}
+function actualType(obj, state) {
+return state.getActualType.call(obj);
+}
+function getMode(obj, state) {
+return prettyModes[state.getDisplayedType.call(obj)];
+}
+function runningPlugin(obj, state) {
+return state.getHasRunningPlugin.call(obj);
+}
+// TODO this is hacky and might hide some failures, but is needed until
+// Bug 767635 lands -- which itself will probably mean tweaking this test.
+function forceReload(obj, state) {
+let attr;
+if (state.tagName == "object")
+attr = "data";
+else if (state.tagName == "embed")
+attr = "src";
+if (attr && hasAttr(obj, attr)) {
+src(obj, state, getAttr(obj, attr));
+} else if (body.contains(obj)) {
+body.appendChild(obj);
+} else {
+// Out of document nodes without data attributes simply can't be
+// reloaded currently. Bug 767635
+}
+};
+// Make a list of combinations of sub-lists, e.g.:
+// [ [a, b], [c, d] ]
+// ->
+// [ [a, c], [a, d], [b, c], [b, d] ]
+function eachList() {
+let all = [];
+if (!arguments.length)
+return all;
+let list = Array.prototype.slice.call(arguments, 0);
+for (let c of list[0]) {
+if (list.length > 1) {
+for (let x of eachList.apply(this,list.slice(1))) {
+all.push((c.length ? [c] : []).concat(x));
+}
+} else if (c.length) {
+all.push([c]);
+}
+}
+return all;
+}
+let states = {
+svg: function(obj, state) {
+removeAttr(obj, "type");
+src(obj, state, testSVG);
+state.noChannel = false;
+state.expectedType = "image/svg";
+// SVGs are actually image-like subdocuments
+state.expectedMode = "document";
+},
+image: function(obj, state) {
+removeAttr(obj, "type");
+src(obj, state, testPNG);
+state.noChannel = false;
+state.expectedMode = "image";
+state.expectedType = "image/png";
+},
+plugin: function(obj, state) {
+removeAttr(obj, "type");
+src(obj, state, "data:application/x-test,foo");
+state.noChannel = false;
+state.expectedType = "application/x-test";
+state.expectedMode = "plugin";
+},
+pluginExtension: function(obj, state) {
+src(obj, state, "./fake_plugin.tst");
+state.expectedMode = "plugin";
+state.pluginExtension = true;
+state.noChannel = false;
+},
+document: function(obj, state) {
+removeAttr(obj, "type");
+src(obj, state, "data:text/plain,I am a document");
+state.noChannel = false;
+state.expectedType = "text/plain";
+state.expectedMode = "document";
+},
+fallback: function(obj, state) {
+removeAttr(obj, "type");
+state.expectedType = "application/x-unknown";
+state.expectedMode = "none";
+state.noChannel = true;
+src(obj, state, null);
+},
+addToDoc: function(obj, state) {
+body.appendChild(obj);
+},
+removeFromDoc: function(obj, state) {
+if (body.contains(obj))
+body.removeChild(obj);
+},
+// Set the proper type
+setType: function(obj, state) {
+if (state.expectedType) {
+state.badType = false;
+setAttr(obj, 'type', state.expectedType);
+forceReload(obj, state);
+}
+},
+// Set an improper type
+setWrongType: function(obj, state) {
+// This should break no-channel-plugins but nothing else
+state.badType = true;
+setAttr(obj, 'type', "application/x-unknown");
+forceReload(obj, state);
+},
+// Set a plugin type
+setPluginType: function(obj, state) {
+// If an object/embed has a type set to a plugin type, it should not
+// use the channel type.
+state.badType = false;
+setAttr(obj, 'type', 'application/x-test');
+state.expectedType = "application/x-test";
+state.expectedMode = "plugin";
+forceReload(obj, state);
+},
+noChannel: function(obj, state) {
+src(obj, state, null);
+state.noChannel = true;
+state.pluginExtension = false;
+},
+displayNone: function(obj, state) {
+setDisplayed(obj, false);
+},
+displayInherit: function(obj, state) {
+setDisplayed(obj, true);
+}
+};
+function testObject(obj, state) {
+// If our test combination both sets noChannel but no explicit type
+// it shouldn't load ever.
+let expectedMode = state.expectedMode;
+let actualMode = getMode(obj, state);
+if (state.noChannel && !getAttr(obj, 'type')) {
+// Some combinations of test both set no type and no channel. This is
+// worth testing with the various combinations, but shouldn't load.
+expectedMode = "none";
+}
+// Embed tags should always try to load a plugin by type or extension
+// before falling back to opening a channel. See bug 803159
+if (state.tagName == "embed" &&
+(getAttr(obj, 'type') == "application/x-test" || state.pluginExtension)) {
+state.noChannel = true;
+}
+// with state.loading, unless we're loading with no channel, these types
+// should still be in loading state pending a channel.
+if (state.loading && (expectedMode == "image" || expectedMode == "document" ||
+(expectedMode == "plugin" && !state.initialPlugin && !state.noChannel))) {
+expectedMode = "loading";
+}
+// With the exception of plugins with a proper type, nothing should
+// load without a channel
+if (state.noChannel && (expectedMode != "plugin" || state.badType) &&
+body.contains(obj)) {
+expectedMode = "none";
+}
+// embed tags should reject documents, except for SVG images which
+// render as such
+if (state.tagName == "embed" && expectedMode == "document" &&
+actualType(obj, state) != "image/svg+xml") {
+expectedMode = "none";
+}
+// Embeds with a plugin type should skip opening a channel prior to
+// loading, taking only type into account.
+if (state.tagName == 'embed' && getAttr(obj, 'type') == 'application/x-test' &&
+body.contains(obj)) {
+expectedMode = "plugin";
+}
+if (!body.contains(obj)
+&& (!state.loading || expectedMode != "image")
+&& (!state.initialPlugin || expectedMode != "plugin")) {
+// Images are handled by nsIImageLoadingContent so we dont track
+// their state change as they're detached and reattached. All other
+// types switch to state "loading", and are completely unloaded
+expectedMode = "loading";
+}
+is(actualMode, expectedMode, "check loaded mode");
+// If we're a plugin, check that we spawned successfully. state.loading
+// is set if we haven't had an event loop since applying state, in which
+// case the plugin would not have stopped yet if it was initially a
+// plugin.
+let shouldBeSpawnable = expectedMode == "plugin" && displayed(obj);
+let shouldSpawn = shouldBeSpawnable && (!state.loading || state.initialPlugin);
+let didSpawn = runningPlugin(obj, state);
+is(didSpawn, !!shouldSpawn, "check plugin spawned is " + !!shouldSpawn);
+// If we are a plugin, scripting should work. If we're not spawned we
+// should spawn synchronously.
+let scripted = false;
+try {
+let x = obj.getObjectValue();
+scripted = true;
+} catch(e) {}
+is(scripted, shouldBeSpawnable, "check plugin scriptability");
+// If this tag previously had other spawned plugins, make sure it
+// respawned between then and now
+if (state.oldPlugins && didSpawn) {
+let didRespawn = false;
+for (let oldp of state.oldPlugins) {
+// If this returns false or throws, it's not the same plugin
+try {
+didRespawn = !obj.checkObjectValue(oldp);
+} catch (e) {
+didRespawn = true;
+}
+}
+is(didRespawn, true, "Plugin should have re-spawned since old state ("+state.oldPlugins.length+")");
+}
+}
+let total = 0;
+let test_modes = {
+// Just apply from_state then to_state
+"immediate": function(obj, from_state, to_state, state) {
+for (let from of from_state)
+states[from](obj, state);
+for (let to of to_state)
+states[to](obj, state);
+// We don't spin the event loop between applying to_state and
+// running tests, so some types are still loading
+state.loading = true;
+info("["+(++total)+"] Testing [ " + from_state + " ] -> [ " + to_state + " ] / " + state.tagName + " / immediate");
+testObject(obj, state);
+if (body.contains(obj))
+body.removeChild(obj);
+},
+// Apply states, spin event loop, run tests.
+"cycle": function(obj, from_state, to_state, state) {
+for (let from of from_state)
+states[from](obj, state);
+for (let to of to_state)
+states[to](obj, state);
+// Because re-appending to the document creates a script blocker, but
+// plugins spawn asynchronously, we need to return to the event loop
+// twice to ensure the plugin has been given a chance to lazily spawn.
+runSoon(function() { runSoon(function() {
+info("["+(++total)+"] Testing [ " + from_state + " ] -> [ " + to_state + " ] / " + state.tagName + " / cycle");
+testObject(obj, state);
+if (body.contains(obj))
+body.removeChild(obj);
+}); });
+},
+// Apply initial state, spin event loop, apply final state, spin event
+// loop again.
+"cycleboth": function(obj, from_state, to_state, state) {
+for (let from of from_state) {
+states[from](obj, state);
+}
+runSoon(function() {
+for (let to of to_state) {
+states[to](obj, state);
+}
+// Because re-appending to the document creates a script blocker,
+// but plugins spawn asynchronously, we need to return to the event
+// loop twice to ensure the plugin has been given a chance to lazily
+// spawn.
+runSoon(function() { runSoon(function() {
+info("["+(++total)+"] Testing [ " + from_state + " ] -> [ " + to_state + " ] / " + state.tagName + " / cycleboth");
+testObject(obj, state);
+if (body.contains(obj))
+body.removeChild(obj);
+}); });
+});
+},
+// Apply initial state, spin event loop, apply later state, test
+// immediately
+"cyclefirst": function(obj, from_state, to_state, state) {
+for (let from of from_state) {
+states[from](obj, state);
+}
+runSoon(function() {
+state.initialPlugin = runningPlugin(obj, state);
+for (let to of to_state) {
+states[to](obj, state);
+}
+info("["+(++total)+"] Testing [ " + from_state + " ] -> [ " + to_state + " ] / " + state.tagName + " / cyclefirst");
+// We don't spin the event loop between applying to_state and
+// running tests, so some types are still loading
+state.loading = true;
+testObject(obj, state);
+if (body.contains(obj))
+body.removeChild(obj);
+});
+},
+};
+function test(testdat) {
+for (let from_state of testdat['from_states']) {
+for (let to_state of testdat['to_states']) {
+for (let mode of testdat['test_modes']) {
+for (let type of testdat['tag_types']) {
+runSoon(function () {
+let obj = document.createElement(type);
+obj.width = 1; obj.height = 1;
+let state = {};
+state.noChannel = true;
+state.tagName = type;
+// Part of the test checks whether a plugin spawned or not,
+// but touching the object prototype will attempt to
+// synchronously spawn a plugin!  We use this terrible hack to
+// get a privileged getter for the attributes we want to touch
+// prior to applying any attributes.
+// TODO when embed goes away we wont need to check for
+//      QueryInterface any longer.
+var lookup_on = obj.QueryInterface ? obj.QueryInterface(OBJLC): obj;
+state.getDisplayedType = SpecialPowers.do_lookupGetter(lookup_on, 'displayedType');
+state.getHasRunningPlugin = SpecialPowers.do_lookupGetter(lookup_on, 'hasRunningPlugin');
+state.getActualType = SpecialPowers.do_lookupGetter(lookup_on, 'actualType');
+test_modes[mode](obj, from_state, to_state, state);
+});
+}
+}
+}
+}
+}
+function onLoad() {
+// Generic tests
+test({
+'tag_types': [ 'embed', 'object' ],
+// In all three modes
+'test_modes': [ 'immediate', 'cycle', 'cyclefirst', 'cycleboth' ],
+// Starting from a blank tag in and out of the document, a loading
+// plugin, and no-channel plugin (initial types only really have
+// odd cases with plugins)
+'from_states': [
+[ 'addToDoc' ],
+[ 'plugin' ],
+[ 'plugin', 'addToDoc' ],
+[ 'plugin', 'noChannel', 'setType', 'addToDoc' ],
+[],
+],
+// To various combinations of loaded objects
+'to_states': eachList(
+[ 'svg', 'image', 'plugin', 'document', '' ],
+[ 'setType', 'setWrongType', 'setPluginType', '' ],
+[ 'noChannel', '' ],
+[ 'displayNone', 'displayInherit', '' ]
+)});
+// Special case test for embed tags with plugin-by-extension
+// TODO object tags should be tested here too -- they have slightly
+//      different behavior, but waiting on a file load requires a loaded
+//      event handler and wont work with just our event loop spinning.
+test({
+'tag_types': [ 'embed' ],
+'test_modes': [ 'immediate', 'cyclefirst', 'cycle', 'cycleboth' ],
+'from_states': eachList(
+[ 'svg', 'plugin', 'image', 'document' ],
+[ 'addToDoc' ]
+),
+// Set extension along with valid ty
+'to_states': [
+[ 'pluginExtension' ]
+]});
+// Test plugin add/remove from document with adding/removing frame, with
+// and without a channel.
+test({
+'tag_types': [ 'embed', 'object' ], // Ideally we'd test object too, but this gets exponentially long.
+'test_modes': [ 'immediate', 'cyclefirst', 'cycle' ],
+'from_states': [ [ 'displayNone', 'plugin', 'addToDoc' ],
+[ 'displayNone', 'plugin', 'noChannel', 'addToDoc' ],
+[ 'plugin', 'noChannel', 'addToDoc' ],
+[ 'plugin', 'noChannel' ] ],
+'to_states': eachList(
+[ 'displayNone', '' ],
+[ 'removeFromDoc' ],
+[ 'image', 'displayNone', '' ],
+[ 'image', 'displayNone', '' ],
+[ 'addToDoc' ],
+[ 'displayInherit' ]
+)});
+runWhenDone(function() SimpleTest.finish());
+}
+</script>

The Tor Browser / file comparison

comparison: content/base/test/test_object.html

content/base/test/test_object.html