summaryrefslogtreecommitdiffstats
path: root/layout/tools/reftest/reftest.jsm
diff options
context:
space:
mode:
Diffstat (limited to 'layout/tools/reftest/reftest.jsm')
-rw-r--r--layout/tools/reftest/reftest.jsm2112
1 files changed, 2112 insertions, 0 deletions
diff --git a/layout/tools/reftest/reftest.jsm b/layout/tools/reftest/reftest.jsm
new file mode 100644
index 000000000..69d804453
--- /dev/null
+++ b/layout/tools/reftest/reftest.jsm
@@ -0,0 +1,2112 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- /
+/* vim: set shiftwidth=4 tabstop=8 autoindent cindent expandtab: */
+/* 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/. */
+
+this.EXPORTED_SYMBOLS = ["OnRefTestLoad", "OnRefTestUnload"];
+
+var CC = Components.classes;
+const CI = Components.interfaces;
+const CR = Components.results;
+const CU = Components.utils;
+
+const XHTML_NS = "http://www.w3.org/1999/xhtml";
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+const NS_LOCAL_FILE_CONTRACTID = "@mozilla.org/file/local;1";
+const NS_GFXINFO_CONTRACTID = "@mozilla.org/gfx/info;1";
+const IO_SERVICE_CONTRACTID = "@mozilla.org/network/io-service;1";
+const DEBUG_CONTRACTID = "@mozilla.org/xpcom/debug;1";
+const NS_LOCALFILEINPUTSTREAM_CONTRACTID =
+ "@mozilla.org/network/file-input-stream;1";
+const NS_SCRIPTSECURITYMANAGER_CONTRACTID =
+ "@mozilla.org/scriptsecuritymanager;1";
+const NS_REFTESTHELPER_CONTRACTID =
+ "@mozilla.org/reftest-helper;1";
+const NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX =
+ "@mozilla.org/network/protocol;1?name=";
+const NS_XREAPPINFO_CONTRACTID =
+ "@mozilla.org/xre/app-info;1";
+const NS_DIRECTORY_SERVICE_CONTRACTID =
+ "@mozilla.org/file/directory_service;1";
+const NS_OBSERVER_SERVICE_CONTRACTID =
+ "@mozilla.org/observer-service;1";
+
+CU.import("resource://gre/modules/FileUtils.jsm");
+CU.import("chrome://reftest/content/httpd.jsm", this);
+CU.import("chrome://reftest/content/StructuredLog.jsm", this);
+CU.import("resource://gre/modules/Services.jsm");
+CU.import("resource://gre/modules/NetUtil.jsm");
+
+var gLoadTimeout = 0;
+var gTimeoutHook = null;
+var gRemote = false;
+var gIgnoreWindowSize = false;
+var gShuffle = false;
+var gRepeat = null;
+var gRunUntilFailure = false;
+var gTotalChunks = 0;
+var gThisChunk = 0;
+var gContainingWindow = null;
+var gURLFilterRegex = {};
+var gContentGfxInfo = null;
+const FOCUS_FILTER_ALL_TESTS = "all";
+const FOCUS_FILTER_NEEDS_FOCUS_TESTS = "needs-focus";
+const FOCUS_FILTER_NON_NEEDS_FOCUS_TESTS = "non-needs-focus";
+var gFocusFilterMode = FOCUS_FILTER_ALL_TESTS;
+
+// "<!--CLEAR-->"
+const BLANK_URL_FOR_CLEARING = "data:text/html;charset=UTF-8,%3C%21%2D%2DCLEAR%2D%2D%3E";
+
+var gBrowser;
+// Are we testing web content loaded in a separate process?
+var gBrowserIsRemote; // bool
+var gB2GisMulet; // bool
+// Are we using <iframe mozbrowser>?
+var gBrowserIsIframe; // bool
+var gBrowserMessageManager;
+var gCanvas1, gCanvas2;
+// gCurrentCanvas is non-null between InitCurrentCanvasWithSnapshot and the next
+// RecordResult.
+var gCurrentCanvas = null;
+var gURLs;
+var gManifestsLoaded = {};
+// Map from URI spec to the number of times it remains to be used
+var gURIUseCounts;
+// Map from URI spec to the canvas rendered for that URI
+var gURICanvases;
+var gTestResults = {
+ // Successful...
+ Pass: 0,
+ LoadOnly: 0,
+ // Unexpected...
+ Exception: 0,
+ FailedLoad: 0,
+ UnexpectedFail: 0,
+ UnexpectedPass: 0,
+ AssertionUnexpected: 0,
+ AssertionUnexpectedFixed: 0,
+ // Known problems...
+ KnownFail : 0,
+ AssertionKnown: 0,
+ Random : 0,
+ Skip: 0,
+ Slow: 0,
+};
+var gTotalTests = 0;
+var gState;
+var gCurrentURL;
+var gTestLog = [];
+var gLogLevel;
+var gServer;
+var gCount = 0;
+var gAssertionCount = 0;
+
+var gIOService;
+var gDebug;
+var gWindowUtils;
+
+var gSlowestTestTime = 0;
+var gSlowestTestURL;
+var gFailedUseWidgetLayers = false;
+
+var gDrawWindowFlags;
+
+var gExpectingProcessCrash = false;
+var gExpectedCrashDumpFiles = [];
+var gUnexpectedCrashDumpFiles = { };
+var gCrashDumpDir;
+var gFailedNoPaint = false;
+var gFailedOpaqueLayer = false;
+var gFailedOpaqueLayerMessages = [];
+var gFailedAssignedLayer = false;
+var gFailedAssignedLayerMessages = [];
+
+// The enabled-state of the test-plugins, stored so they can be reset later
+var gTestPluginEnabledStates = null;
+
+const TYPE_REFTEST_EQUAL = '==';
+const TYPE_REFTEST_NOTEQUAL = '!=';
+const TYPE_LOAD = 'load'; // test without a reference (just test that it does
+ // not assert, crash, hang, or leak)
+const TYPE_SCRIPT = 'script'; // test contains individual test results
+
+// The order of these constants matters, since when we have a status
+// listed for a *manifest*, we combine the status with the status for
+// the test by using the *larger*.
+// FIXME: In the future, we may also want to use this rule for combining
+// statuses that are on the same line (rather than making the last one
+// win).
+const EXPECTED_PASS = 0;
+const EXPECTED_FAIL = 1;
+const EXPECTED_RANDOM = 2;
+const EXPECTED_DEATH = 3; // test must be skipped to avoid e.g. crash/hang
+const EXPECTED_FUZZY = 4;
+
+// types of preference value we might want to set for a specific test
+const PREF_BOOLEAN = 0;
+const PREF_STRING = 1;
+const PREF_INTEGER = 2;
+
+var gPrefsToRestore = [];
+
+const gProtocolRE = /^\w+:/;
+const gPrefItemRE = /^(|test-|ref-)pref\((.+?),(.*)\)$/;
+
+var gHttpServerPort = -1;
+
+// whether to run slow tests or not
+var gRunSlowTests = true;
+
+// whether we should skip caching canvases
+var gNoCanvasCache = false;
+
+var gRecycledCanvases = new Array();
+
+// Only dump the sandbox once, because it doesn't depend on the
+// manifest URL (yet!).
+var gDumpedConditionSandbox = false;
+
+function HasUnexpectedResult()
+{
+ return gTestResults.Exception > 0 ||
+ gTestResults.FailedLoad > 0 ||
+ gTestResults.UnexpectedFail > 0 ||
+ gTestResults.UnexpectedPass > 0 ||
+ gTestResults.AssertionUnexpected > 0 ||
+ gTestResults.AssertionUnexpectedFixed > 0;
+}
+
+// By default we just log to stdout
+var gLogFile = null;
+var gDumpFn = function(line) {
+ dump(line);
+ if (gLogFile) {
+ gLogFile.write(line, line.length);
+ }
+}
+var gDumpRawLog = function(record) {
+ // Dump JSON representation of data on a single line
+ var line = "\n" + JSON.stringify(record) + "\n";
+ dump(line);
+
+ if (gLogFile) {
+ gLogFile.write(line, line.length);
+ }
+}
+var logger = new StructuredLogger('reftest', gDumpRawLog);
+
+function TestBuffer(str)
+{
+ logger.debug(str);
+ gTestLog.push(str);
+}
+
+function FlushTestBuffer()
+{
+ // In debug mode, we've dumped all these messages already.
+ if (gLogLevel !== 'debug') {
+ for (var i = 0; i < gTestLog.length; ++i) {
+ logger.info("Saved log: " + gTestLog[i]);
+ }
+ }
+ gTestLog = [];
+}
+
+function LogWidgetLayersFailure()
+{
+ logger.error("USE_WIDGET_LAYERS disabled because the screen resolution is too low. This falls back to an alternate rendering path (that may not be representative) and is not implemented with e10s enabled.");
+ logger.error("Consider increasing your screen resolution, or adding '--disable-e10s' to your './mach reftest' command");
+}
+
+function AllocateCanvas()
+{
+ if (gRecycledCanvases.length > 0) {
+ return gRecycledCanvases.shift();
+ }
+
+ var canvas = gContainingWindow.document.createElementNS(XHTML_NS, "canvas");
+ var r = gBrowser.getBoundingClientRect();
+ canvas.setAttribute("width", Math.ceil(r.width));
+ canvas.setAttribute("height", Math.ceil(r.height));
+
+ return canvas;
+}
+
+function ReleaseCanvas(canvas)
+{
+ // store a maximum of 2 canvases, if we're not caching
+ if (!gNoCanvasCache || gRecycledCanvases.length < 2) {
+ gRecycledCanvases.push(canvas);
+ }
+}
+
+function IDForEventTarget(event)
+{
+ try {
+ return "'" + event.target.getAttribute('id') + "'";
+ } catch (ex) {
+ return "<unknown>";
+ }
+}
+
+function getTestPlugin(aName) {
+ var ph = CC["@mozilla.org/plugin/host;1"].getService(CI.nsIPluginHost);
+ var tags = ph.getPluginTags();
+
+ // Find the test plugin
+ for (var i = 0; i < tags.length; i++) {
+ if (tags[i].name == aName)
+ return tags[i];
+ }
+
+ logger.warning("Failed to find the test-plugin.");
+ return null;
+}
+
+this.OnRefTestLoad = function OnRefTestLoad(win)
+{
+ gCrashDumpDir = CC[NS_DIRECTORY_SERVICE_CONTRACTID]
+ .getService(CI.nsIProperties)
+ .get("ProfD", CI.nsIFile);
+ gCrashDumpDir.append("minidumps");
+
+ var env = CC["@mozilla.org/process/environment;1"].
+ getService(CI.nsIEnvironment);
+
+ var prefs = Components.classes["@mozilla.org/preferences-service;1"].
+ getService(Components.interfaces.nsIPrefBranch);
+ try {
+ gBrowserIsRemote = prefs.getBoolPref("browser.tabs.remote.autostart");
+ } catch (e) {
+ gBrowserIsRemote = false;
+ }
+
+ try {
+ gB2GisMulet = prefs.getBoolPref("b2g.is_mulet");
+ } catch (e) {
+ gB2GisMulet = false;
+ }
+
+ try {
+ gBrowserIsIframe = prefs.getBoolPref("reftest.browser.iframe.enabled");
+ } catch (e) {
+ gBrowserIsIframe = false;
+ }
+
+ try {
+ gLogLevel = prefs.getCharPref("reftest.logLevel");
+ } catch (e) {
+ gLogLevel ='info';
+ }
+
+ if (win === undefined || win == null) {
+ win = window;
+ }
+ if (gContainingWindow == null && win != null) {
+ gContainingWindow = win;
+ }
+
+ if (gBrowserIsIframe) {
+ gBrowser = gContainingWindow.document.createElementNS(XHTML_NS, "iframe");
+ gBrowser.setAttribute("mozbrowser", "");
+ gBrowser.setAttribute("mozapp", prefs.getCharPref("b2g.system_manifest_url"));
+ } else {
+ gBrowser = gContainingWindow.document.createElementNS(XUL_NS, "xul:browser");
+ }
+ gBrowser.setAttribute("id", "browser");
+ gBrowser.setAttribute("type", "content-primary");
+ gBrowser.setAttribute("remote", gBrowserIsRemote ? "true" : "false");
+ // Make sure the browser element is exactly 800x1000, no matter
+ // what size our window is
+ gBrowser.setAttribute("style", "padding: 0px; margin: 0px; border:none; min-width: 800px; min-height: 1000px; max-width: 800px; max-height: 1000px");
+
+ if (Services.appinfo.OS == "Android") {
+ let doc;
+ if (Services.appinfo.widgetToolkit == "gonk") {
+ doc = gContainingWindow.document.getElementsByTagName("html")[0];
+ } else {
+ doc = gContainingWindow.document.getElementById('main-window');
+ }
+ while (doc.hasChildNodes()) {
+ doc.removeChild(doc.firstChild);
+ }
+ doc.appendChild(gBrowser);
+ } else {
+ document.getElementById("reftest-window").appendChild(gBrowser);
+ }
+
+ // reftests should have the test plugins enabled, not click-to-play
+ let plugin1 = getTestPlugin("Test Plug-in");
+ let plugin2 = getTestPlugin("Second Test Plug-in");
+ if (plugin1 && plugin2) {
+ gTestPluginEnabledStates = [plugin1.enabledState, plugin2.enabledState];
+ plugin1.enabledState = CI.nsIPluginTag.STATE_ENABLED;
+ plugin2.enabledState = CI.nsIPluginTag.STATE_ENABLED;
+ } else {
+ logger.warning("Could not get test plugin tags.");
+ }
+
+ gBrowserMessageManager = gBrowser.QueryInterface(CI.nsIFrameLoaderOwner)
+ .frameLoader.messageManager;
+ // The content script waits for the initial onload, then notifies
+ // us.
+ RegisterMessageListenersAndLoadContentScript();
+}
+
+function InitAndStartRefTests()
+{
+ /* These prefs are optional, so we don't need to spit an error to the log */
+ try {
+ var prefs = Components.classes["@mozilla.org/preferences-service;1"].
+ getService(Components.interfaces.nsIPrefBranch);
+ } catch(e) {
+ logger.error("EXCEPTION: " + e);
+ }
+
+ try {
+ prefs.setBoolPref("android.widget_paints_background", false);
+ } catch (e) {}
+
+ /* set the gLoadTimeout */
+ try {
+ gLoadTimeout = prefs.getIntPref("reftest.timeout");
+ } catch(e) {
+ gLoadTimeout = 5 * 60 * 1000; //5 minutes as per bug 479518
+ }
+
+ /* Get the logfile for android tests */
+ try {
+ var logFile = prefs.getCharPref("reftest.logFile");
+ if (logFile) {
+ var f = FileUtils.File(logFile);
+ gLogFile = FileUtils.openFileOutputStream(f, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE);
+ }
+ } catch(e) {}
+
+ try {
+ gRemote = prefs.getBoolPref("reftest.remote");
+ } catch(e) {
+ gRemote = false;
+ }
+
+ try {
+ gIgnoreWindowSize = prefs.getBoolPref("reftest.ignoreWindowSize");
+ } catch(e) {
+ gIgnoreWindowSize = false;
+ }
+
+ /* Support for running a chunk (subset) of tests. In separate try as this is optional */
+ try {
+ gTotalChunks = prefs.getIntPref("reftest.totalChunks");
+ gThisChunk = prefs.getIntPref("reftest.thisChunk");
+ }
+ catch(e) {
+ gTotalChunks = 0;
+ gThisChunk = 0;
+ }
+
+ try {
+ gFocusFilterMode = prefs.getCharPref("reftest.focusFilterMode");
+ } catch(e) {}
+
+ gWindowUtils = gContainingWindow.QueryInterface(CI.nsIInterfaceRequestor).getInterface(CI.nsIDOMWindowUtils);
+ if (!gWindowUtils || !gWindowUtils.compareCanvases)
+ throw "nsIDOMWindowUtils inteface missing";
+
+ gIOService = CC[IO_SERVICE_CONTRACTID].getService(CI.nsIIOService);
+ gDebug = CC[DEBUG_CONTRACTID].getService(CI.nsIDebug2);
+
+ RegisterProcessCrashObservers();
+
+ if (gRemote) {
+ gServer = null;
+ } else {
+ gServer = new HttpServer();
+ }
+ try {
+ if (gServer)
+ StartHTTPServer();
+ } catch (ex) {
+ //gBrowser.loadURI('data:text/plain,' + ex);
+ ++gTestResults.Exception;
+ logger.error("EXCEPTION: " + ex);
+ DoneTests();
+ }
+
+ // Focus the content browser.
+ if (gFocusFilterMode != FOCUS_FILTER_NON_NEEDS_FOCUS_TESTS) {
+ gBrowser.focus();
+ }
+
+ StartTests();
+}
+
+function StartHTTPServer()
+{
+ gServer.registerContentType("sjs", "sjs");
+ gServer.start(-1);
+ gHttpServerPort = gServer.identity.primaryPort;
+}
+
+// Perform a Fisher-Yates shuffle of the array.
+function Shuffle(array)
+{
+ for (var i = array.length - 1; i > 0; i--) {
+ var j = Math.floor(Math.random() * (i + 1));
+ var temp = array[i];
+ array[i] = array[j];
+ array[j] = temp;
+ }
+}
+
+function StartTests()
+{
+ var manifests;
+ /* These prefs are optional, so we don't need to spit an error to the log */
+ try {
+ var prefs = Components.classes["@mozilla.org/preferences-service;1"].
+ getService(Components.interfaces.nsIPrefBranch);
+ } catch(e) {
+ logger.error("EXCEPTION: " + e);
+ }
+
+ try {
+ gNoCanvasCache = prefs.getIntPref("reftest.nocache");
+ } catch(e) {
+ gNoCanvasCache = false;
+ }
+
+ try {
+ gShuffle = prefs.getBoolPref("reftest.shuffle");
+ } catch (e) {
+ gShuffle = false;
+ }
+
+ try {
+ gRunUntilFailure = prefs.getBoolPref("reftest.runUntilFailure");
+ } catch (e) {
+ gRunUntilFailure = false;
+ }
+
+ // When we repeat this function is called again, so really only want to set
+ // gRepeat once.
+ if (gRepeat == null) {
+ try {
+ gRepeat = prefs.getIntPref("reftest.repeat");
+ } catch (e) {
+ gRepeat = 0;
+ }
+ }
+
+ try {
+ gRunSlowTests = prefs.getIntPref("reftest.skipslowtests");
+ } catch(e) {
+ gRunSlowTests = false;
+ }
+
+ if (gShuffle) {
+ gNoCanvasCache = true;
+ }
+
+ gURLs = [];
+ gManifestsLoaded = {};
+
+ try {
+ var manifests = JSON.parse(prefs.getCharPref("reftest.manifests"));
+ gURLFilterRegex = manifests[null];
+ } catch(e) {
+ logger.error("Unable to find reftest.manifests pref. Please ensure your profile is setup properly");
+ DoneTests();
+ }
+
+ try {
+ var globalFilter = manifests.hasOwnProperty("") ? new RegExp(manifests[""]) : null;
+ var manifestURLs = Object.keys(manifests);
+
+ // Ensure we read manifests from higher up the directory tree first so that we
+ // process includes before reading the included manifest again
+ manifestURLs.sort(function(a,b) {return a.length - b.length})
+ manifestURLs.forEach(function(manifestURL) {
+ logger.info("Reading manifest " + manifestURL);
+ var filter = manifests[manifestURL] ? new RegExp(manifests[manifestURL]) : null;
+ ReadTopManifest(manifestURL, [globalFilter, filter, false]);
+ });
+ BuildUseCounts();
+
+ // Filter tests which will be skipped to get a more even distribution when chunking
+ // tURLs is a temporary array containing all active tests
+ var tURLs = new Array();
+ var tIDs = new Array();
+ for (var i = 0; i < gURLs.length; ++i) {
+ if (gURLs[i].expected == EXPECTED_DEATH)
+ continue;
+
+ if (gURLs[i].needsFocus && !Focus())
+ continue;
+
+ if (gURLs[i].slow && !gRunSlowTests)
+ continue;
+
+ tURLs.push(gURLs[i]);
+ tIDs.push(gURLs[i].identifier);
+ }
+
+ logger.suiteStart(tIDs, {"skipped": gURLs.length - tURLs.length});
+
+ if (gTotalChunks > 0 && gThisChunk > 0) {
+ // Calculate start and end indices of this chunk if tURLs array were
+ // divided evenly
+ var testsPerChunk = tURLs.length / gTotalChunks;
+ var start = Math.round((gThisChunk-1) * testsPerChunk);
+ var end = Math.round(gThisChunk * testsPerChunk);
+
+ // Map these indices onto the gURLs array. This avoids modifying the
+ // gURLs array which prevents skipped tests from showing up in the log
+ start = gThisChunk == 1 ? 0 : gURLs.indexOf(tURLs[start]);
+ end = gThisChunk == gTotalChunks ? gURLs.length : gURLs.indexOf(tURLs[end + 1]) - 1;
+ gURLs = gURLs.slice(start, end);
+
+ logger.info("Running chunk " + gThisChunk + " out of " + gTotalChunks + " chunks. " +
+ "tests " + (start+1) + "-" + end + "/" + gURLs.length);
+ }
+
+ if (gShuffle) {
+ Shuffle(gURLs);
+ }
+
+ gTotalTests = gURLs.length;
+
+ if (!gTotalTests)
+ throw "No tests to run";
+
+ gURICanvases = {};
+ StartCurrentTest();
+ } catch (ex) {
+ //gBrowser.loadURI('data:text/plain,' + ex);
+ ++gTestResults.Exception;
+ logger.error("EXCEPTION: " + ex);
+ DoneTests();
+ }
+}
+
+function OnRefTestUnload()
+{
+ let plugin1 = getTestPlugin("Test Plug-in");
+ let plugin2 = getTestPlugin("Second Test Plug-in");
+ if (plugin1 && plugin2) {
+ plugin1.enabledState = gTestPluginEnabledStates[0];
+ plugin2.enabledState = gTestPluginEnabledStates[1];
+ } else {
+ logger.warning("Failed to get test plugin tags.");
+ }
+}
+
+// Read all available data from an input stream and return it
+// as a string.
+function getStreamContent(inputStream)
+{
+ var streamBuf = "";
+ var sis = CC["@mozilla.org/scriptableinputstream;1"].
+ createInstance(CI.nsIScriptableInputStream);
+ sis.init(inputStream);
+
+ var available;
+ while ((available = sis.available()) != 0) {
+ streamBuf += sis.read(available);
+ }
+
+ return streamBuf;
+}
+
+// Build the sandbox for fails-if(), etc., condition evaluation.
+function BuildConditionSandbox(aURL) {
+ var sandbox = new Components.utils.Sandbox(aURL.spec);
+ var xr = CC[NS_XREAPPINFO_CONTRACTID].getService(CI.nsIXULRuntime);
+ var appInfo = CC[NS_XREAPPINFO_CONTRACTID].getService(CI.nsIXULAppInfo);
+ sandbox.isDebugBuild = gDebug.isDebugBuild;
+
+ // xr.XPCOMABI throws exception for configurations without full ABI
+ // support (mobile builds on ARM)
+ var XPCOMABI = "";
+ try {
+ XPCOMABI = xr.XPCOMABI;
+ } catch(e) {}
+
+ sandbox.xulRuntime = CU.cloneInto({widgetToolkit: xr.widgetToolkit, OS: xr.OS, XPCOMABI: XPCOMABI}, sandbox);
+
+ var testRect = gBrowser.getBoundingClientRect();
+ sandbox.smallScreen = false;
+ if (gContainingWindow.innerWidth < 800 || gContainingWindow.innerHeight < 1000) {
+ sandbox.smallScreen = true;
+ }
+
+ var gfxInfo = (NS_GFXINFO_CONTRACTID in CC) && CC[NS_GFXINFO_CONTRACTID].getService(CI.nsIGfxInfo);
+ let readGfxInfo = function (obj, key) {
+ if (gContentGfxInfo && (key in gContentGfxInfo)) {
+ return gContentGfxInfo[key];
+ }
+ return obj[key];
+ }
+
+ try {
+ sandbox.d2d = readGfxInfo(gfxInfo, "D2DEnabled");
+ sandbox.dwrite = readGfxInfo(gfxInfo, "DWriteEnabled");
+ } catch (e) {
+ sandbox.d2d = false;
+ sandbox.dwrite = false;
+ }
+
+ var info = gfxInfo.getInfo();
+ var canvasBackend = readGfxInfo(info, "AzureCanvasBackend");
+ var contentBackend = readGfxInfo(info, "AzureContentBackend");
+ var canvasAccelerated = readGfxInfo(info, "AzureCanvasAccelerated");
+
+ sandbox.azureCairo = canvasBackend == "cairo";
+ sandbox.azureQuartz = canvasBackend == "quartz";
+ sandbox.azureSkia = canvasBackend == "skia";
+ sandbox.skiaContent = contentBackend == "skia";
+ sandbox.azureSkiaGL = canvasAccelerated; // FIXME: assumes GL right now
+ // true if we are using the same Azure backend for rendering canvas and content
+ sandbox.contentSameGfxBackendAsCanvas = contentBackend == canvasBackend
+ || (contentBackend == "none" && canvasBackend == "cairo");
+
+ sandbox.layersGPUAccelerated =
+ gWindowUtils.layerManagerType != "Basic";
+ sandbox.d3d11 =
+ gWindowUtils.layerManagerType == "Direct3D 11";
+ sandbox.d3d9 =
+ gWindowUtils.layerManagerType == "Direct3D 9";
+ sandbox.layersOpenGL =
+ gWindowUtils.layerManagerType == "OpenGL";
+ sandbox.layersOMTC =
+ gWindowUtils.layerManagerRemote == true;
+
+ // Shortcuts for widget toolkits.
+ sandbox.B2G = xr.widgetToolkit == "gonk";
+ sandbox.Android = xr.OS == "Android" && !sandbox.B2G;
+ sandbox.cocoaWidget = xr.widgetToolkit == "cocoa";
+ sandbox.gtkWidget = xr.widgetToolkit == "gtk2"
+ || xr.widgetToolkit == "gtk3";
+ sandbox.qtWidget = xr.widgetToolkit == "qt";
+ sandbox.winWidget = xr.widgetToolkit == "windows";
+
+ // Scrollbars that are semi-transparent. See bug 1169666.
+ sandbox.transparentScrollbars = xr.widgetToolkit == "gtk3";
+
+ if (sandbox.Android) {
+ var sysInfo = CC["@mozilla.org/system-info;1"].getService(CI.nsIPropertyBag2);
+
+ // This is currently used to distinguish Android 4.0.3 (SDK version 15)
+ // and later from Android 2.x
+ sandbox.AndroidVersion = sysInfo.getPropertyAsInt32("version");
+ }
+
+#if MOZ_ASAN
+ sandbox.AddressSanitizer = true;
+#else
+ sandbox.AddressSanitizer = false;
+#endif
+
+#if MOZ_WEBRTC
+ sandbox.webrtc = true;
+#else
+ sandbox.webrtc = false;
+#endif
+
+ var hh = CC[NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX + "http"].
+ getService(CI.nsIHttpProtocolHandler);
+ var httpProps = ["userAgent", "appName", "appVersion", "vendor",
+ "vendorSub", "product", "productSub", "platform",
+ "oscpu", "language", "misc"];
+ sandbox.http = new sandbox.Object();
+ httpProps.forEach((x) => sandbox.http[x] = hh[x]);
+
+ // Set OSX to be the Mac OS X version, as an integer, or undefined
+ // for other platforms. The integer is formed by 100 times the
+ // major version plus the minor version, so 1006 for 10.6, 1010 for
+ // 10.10, etc.
+ var osxmatch = /Mac OS X (\d+).(\d+)$/.exec(hh.oscpu);
+ sandbox.OSX = osxmatch ? parseInt(osxmatch[1]) * 100 + parseInt(osxmatch[2]) : undefined;
+
+ // see if we have the test plugin available,
+ // and set a sandox prop accordingly
+ var navigator = gContainingWindow.navigator;
+ var testPlugin = navigator.plugins["Test Plug-in"];
+ sandbox.haveTestPlugin = !!testPlugin;
+
+ // Set a flag on sandbox if the windows default theme is active
+ sandbox.windowsDefaultTheme = gContainingWindow.matchMedia("(-moz-windows-default-theme)").matches;
+
+ var prefs = CC["@mozilla.org/preferences-service;1"].
+ getService(CI.nsIPrefBranch);
+ try {
+ sandbox.nativeThemePref = !prefs.getBoolPref("mozilla.widget.disable-native-theme");
+ } catch (e) {
+ sandbox.nativeThemePref = true;
+ }
+
+ sandbox.prefs = CU.cloneInto({
+ getBoolPref: function(p) { return prefs.getBoolPref(p); },
+ getIntPref: function(p) { return prefs.getIntPref(p); }
+ }, sandbox, { cloneFunctions: true });
+
+ // Tests shouldn't care about this except for when they need to
+ // crash the content process
+ sandbox.browserIsRemote = gBrowserIsRemote;
+ sandbox.Mulet = gB2GisMulet;
+
+ try {
+ sandbox.asyncPan = gContainingWindow.document.docShell.asyncPanZoomEnabled;
+ } catch (e) {
+ sandbox.asyncPan = false;
+ }
+
+ if (!gDumpedConditionSandbox) {
+ logger.info("Dumping JSON representation of sandbox");
+ logger.info(JSON.stringify(CU.waiveXrays(sandbox)));
+ gDumpedConditionSandbox = true;
+ }
+
+ // Graphics features
+ sandbox.usesRepeatResampling = sandbox.d2d;
+ return sandbox;
+}
+
+function AddPrefSettings(aWhere, aPrefName, aPrefValExpression, aSandbox, aTestPrefSettings, aRefPrefSettings)
+{
+ var prefVal = Components.utils.evalInSandbox("(" + aPrefValExpression + ")", aSandbox);
+ var prefType;
+ var valType = typeof(prefVal);
+ if (valType == "boolean") {
+ prefType = PREF_BOOLEAN;
+ } else if (valType == "string") {
+ prefType = PREF_STRING;
+ } else if (valType == "number" && (parseInt(prefVal) == prefVal)) {
+ prefType = PREF_INTEGER;
+ } else {
+ return false;
+ }
+ var setting = { name: aPrefName,
+ type: prefType,
+ value: prefVal };
+ if (aWhere != "ref-") {
+ aTestPrefSettings.push(setting);
+ }
+ if (aWhere != "test-") {
+ aRefPrefSettings.push(setting);
+ }
+ return true;
+}
+
+function ReadTopManifest(aFileURL, aFilter)
+{
+ var url = gIOService.newURI(aFileURL, null, null);
+ if (!url)
+ throw "Expected a file or http URL for the manifest.";
+ ReadManifest(url, EXPECTED_PASS, aFilter);
+}
+
+function AddTestItem(aTest, aFilter)
+{
+ if (!aFilter)
+ aFilter = [null, [], false];
+
+ globalFilter = aFilter[0];
+ manifestFilter = aFilter[1];
+ invertManifest = aFilter[2];
+ if ((globalFilter && !globalFilter.test(aTest.url1.spec)) ||
+ (manifestFilter &&
+ !(invertManifest ^ manifestFilter.test(aTest.url1.spec))))
+ return;
+ if (gFocusFilterMode == FOCUS_FILTER_NEEDS_FOCUS_TESTS &&
+ !aTest.needsFocus)
+ return;
+ if (gFocusFilterMode == FOCUS_FILTER_NON_NEEDS_FOCUS_TESTS &&
+ aTest.needsFocus)
+ return;
+
+ if (aTest.url2 !== null)
+ aTest.identifier = [aTest.prettyPath, aTest.type, aTest.url2.spec];
+ else
+ aTest.identifier = aTest.prettyPath;
+
+ gURLs.push(aTest);
+}
+
+// Note: If you materially change the reftest manifest parsing,
+// please keep the parser in print-manifest-dirs.py in sync.
+function ReadManifest(aURL, inherited_status, aFilter)
+{
+ // Ensure each manifest is only read once. This assumes that manifests that are
+ // included with an unusual inherited_status or filters will be read via their
+ // include before they are read directly in the case of a duplicate
+ if (gManifestsLoaded.hasOwnProperty(aURL.spec)) {
+ if (gManifestsLoaded[aURL.spec] === null)
+ return;
+ else
+ aFilter = [aFilter[0], aFilter[1], true];
+ }
+ gManifestsLoaded[aURL.spec] = aFilter[1];
+
+ var secMan = CC[NS_SCRIPTSECURITYMANAGER_CONTRACTID]
+ .getService(CI.nsIScriptSecurityManager);
+
+ var listURL = aURL;
+ var channel = NetUtil.newChannel({uri: aURL, loadUsingSystemPrincipal: true});
+ var inputStream = channel.open2();
+ if (channel instanceof Components.interfaces.nsIHttpChannel
+ && channel.responseStatus != 200) {
+ logger.error("HTTP ERROR : " + channel.responseStatus);
+ }
+ var streamBuf = getStreamContent(inputStream);
+ inputStream.close();
+ var lines = streamBuf.split(/\n|\r|\r\n/);
+
+ // Build the sandbox for fails-if(), etc., condition evaluation.
+ var sandbox = BuildConditionSandbox(aURL);
+ var lineNo = 0;
+ var urlprefix = "";
+ var defaultTestPrefSettings = [], defaultRefPrefSettings = [];
+ for (var str of lines) {
+ ++lineNo;
+ if (str.charAt(0) == "#")
+ continue; // entire line was a comment
+ var i = str.search(/\s+#/);
+ if (i >= 0)
+ str = str.substring(0, i);
+ // strip leading and trailing whitespace
+ str = str.replace(/^\s*/, '').replace(/\s*$/, '');
+ if (!str || str == "")
+ continue;
+ var items = str.split(/\s+/); // split on whitespace
+
+ if (items[0] == "url-prefix") {
+ if (items.length != 2)
+ throw "url-prefix requires one url in manifest file " + aURL.spec + " line " + lineNo;
+ urlprefix = items[1];
+ continue;
+ }
+
+ if (items[0] == "default-preferences") {
+ var m;
+ var item;
+ defaultTestPrefSettings = [];
+ defaultRefPrefSettings = [];
+ items.shift();
+ while ((item = items.shift())) {
+ if (!(m = item.match(gPrefItemRE))) {
+ throw "Unexpected item in default-preferences list in manifest file " + aURL.spec + " line " + lineNo;
+ }
+ if (!AddPrefSettings(m[1], m[2], m[3], sandbox, defaultTestPrefSettings, defaultRefPrefSettings)) {
+ throw "Error in pref value in manifest file " + aURL.spec + " line " + lineNo;
+ }
+ }
+ continue;
+ }
+
+ var expected_status = EXPECTED_PASS;
+ var allow_silent_fail = false;
+ var minAsserts = 0;
+ var maxAsserts = 0;
+ var needs_focus = false;
+ var slow = false;
+ var testPrefSettings = defaultTestPrefSettings.concat();
+ var refPrefSettings = defaultRefPrefSettings.concat();
+ var fuzzy_max_delta = 2;
+ var fuzzy_max_pixels = 1;
+ var chaosMode = false;
+
+ while (items[0].match(/^(fails|needs-focus|random|skip|asserts|slow|require-or|silentfail|pref|test-pref|ref-pref|fuzzy|chaos-mode)/)) {
+ var item = items.shift();
+ var stat;
+ var cond;
+ var m = item.match(/^(fails|random|skip|silentfail)-if(\(.*\))$/);
+ if (m) {
+ stat = m[1];
+ // Note: m[2] contains the parentheses, and we want them.
+ cond = Components.utils.evalInSandbox(m[2], sandbox);
+ } else if (item.match(/^(fails|random|skip)$/)) {
+ stat = item;
+ cond = true;
+ } else if (item == "needs-focus") {
+ needs_focus = true;
+ cond = false;
+ } else if ((m = item.match(/^asserts\((\d+)(-\d+)?\)$/))) {
+ cond = false;
+ minAsserts = Number(m[1]);
+ maxAsserts = (m[2] == undefined) ? minAsserts
+ : Number(m[2].substring(1));
+ } else if ((m = item.match(/^asserts-if\((.*?),(\d+)(-\d+)?\)$/))) {
+ cond = false;
+ if (Components.utils.evalInSandbox("(" + m[1] + ")", sandbox)) {
+ minAsserts = Number(m[2]);
+ maxAsserts =
+ (m[3] == undefined) ? minAsserts
+ : Number(m[3].substring(1));
+ }
+ } else if (item == "slow") {
+ cond = false;
+ slow = true;
+ } else if ((m = item.match(/^require-or\((.*?)\)$/))) {
+ var args = m[1].split(/,/);
+ if (args.length != 2) {
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": wrong number of args to require-or";
+ }
+ var [precondition_str, fallback_action] = args;
+ var preconditions = precondition_str.split(/&&/);
+ cond = false;
+ for (var precondition of preconditions) {
+ if (precondition === "debugMode") {
+ // Currently unimplemented. Requires asynchronous
+ // JSD call + getting an event while no JS is running
+ stat = fallback_action;
+ cond = true;
+ break;
+ } else if (precondition === "true") {
+ // For testing
+ } else {
+ // Unknown precondition. Assume it is unimplemented.
+ stat = fallback_action;
+ cond = true;
+ break;
+ }
+ }
+ } else if ((m = item.match(/^slow-if\((.*?)\)$/))) {
+ cond = false;
+ if (Components.utils.evalInSandbox("(" + m[1] + ")", sandbox))
+ slow = true;
+ } else if (item == "silentfail") {
+ cond = false;
+ allow_silent_fail = true;
+ } else if ((m = item.match(gPrefItemRE))) {
+ cond = false;
+ if (!AddPrefSettings(m[1], m[2], m[3], sandbox, testPrefSettings, refPrefSettings)) {
+ throw "Error in pref value in manifest file " + aURL.spec + " line " + lineNo;
+ }
+ } else if ((m = item.match(/^fuzzy\((\d+),(\d+)\)$/))) {
+ cond = false;
+ expected_status = EXPECTED_FUZZY;
+ fuzzy_max_delta = Number(m[1]);
+ fuzzy_max_pixels = Number(m[2]);
+ } else if ((m = item.match(/^fuzzy-if\((.*?),(\d+),(\d+)\)$/))) {
+ cond = false;
+ if (Components.utils.evalInSandbox("(" + m[1] + ")", sandbox)) {
+ expected_status = EXPECTED_FUZZY;
+ fuzzy_max_delta = Number(m[2]);
+ fuzzy_max_pixels = Number(m[3]);
+ }
+ } else if (item == "chaos-mode") {
+ cond = false;
+ chaosMode = true;
+ } else {
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": unexpected item " + item;
+ }
+
+ if (cond) {
+ if (stat == "fails") {
+ expected_status = EXPECTED_FAIL;
+ } else if (stat == "random") {
+ expected_status = EXPECTED_RANDOM;
+ } else if (stat == "skip") {
+ expected_status = EXPECTED_DEATH;
+ } else if (stat == "silentfail") {
+ allow_silent_fail = true;
+ }
+ }
+ }
+
+ expected_status = Math.max(expected_status, inherited_status);
+
+ if (minAsserts > maxAsserts) {
+ throw "Bad range in manifest file " + aURL.spec + " line " + lineNo;
+ }
+
+ var runHttp = false;
+ var httpDepth;
+ if (items[0] == "HTTP") {
+ runHttp = (aURL.scheme == "file"); // We can't yet run the local HTTP server
+ // for non-local reftests.
+ httpDepth = 0;
+ items.shift();
+ } else if (items[0].match(/HTTP\(\.\.(\/\.\.)*\)/)) {
+ // Accept HTTP(..), HTTP(../..), HTTP(../../..), etc.
+ runHttp = (aURL.scheme == "file"); // We can't yet run the local HTTP server
+ // for non-local reftests.
+ httpDepth = (items[0].length - 5) / 3;
+ items.shift();
+ }
+
+ // do not prefix the url for include commands or urls specifying
+ // a protocol
+ if (urlprefix && items[0] != "include") {
+ if (items.length > 1 && !items[1].match(gProtocolRE)) {
+ items[1] = urlprefix + items[1];
+ }
+ if (items.length > 2 && !items[2].match(gProtocolRE)) {
+ items[2] = urlprefix + items[2];
+ }
+ }
+
+ var principal = secMan.createCodebasePrincipal(aURL, {});
+
+ if (items[0] == "include") {
+ if (items.length != 2)
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect number of arguments to include";
+ if (runHttp)
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": use of include with http";
+ var incURI = gIOService.newURI(items[1], null, listURL);
+ secMan.checkLoadURIWithPrincipal(principal, incURI,
+ CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+ ReadManifest(incURI, expected_status, aFilter);
+ } else if (items[0] == TYPE_LOAD) {
+ if (items.length != 2)
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect number of arguments to load";
+ if (expected_status != EXPECTED_PASS &&
+ expected_status != EXPECTED_DEATH)
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect known failure type for load test";
+ var [testURI] = runHttp
+ ? ServeFiles(principal, httpDepth,
+ listURL, [items[1]])
+ : [gIOService.newURI(items[1], null, listURL)];
+ var prettyPath = runHttp
+ ? gIOService.newURI(items[1], null, listURL).spec
+ : testURI.spec;
+ secMan.checkLoadURIWithPrincipal(principal, testURI,
+ CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+ AddTestItem({ type: TYPE_LOAD,
+ expected: expected_status,
+ allowSilentFail: allow_silent_fail,
+ prettyPath: prettyPath,
+ minAsserts: minAsserts,
+ maxAsserts: maxAsserts,
+ needsFocus: needs_focus,
+ slow: slow,
+ prefSettings1: testPrefSettings,
+ prefSettings2: refPrefSettings,
+ fuzzyMaxDelta: fuzzy_max_delta,
+ fuzzyMaxPixels: fuzzy_max_pixels,
+ url1: testURI,
+ url2: null,
+ chaosMode: chaosMode }, aFilter);
+ } else if (items[0] == TYPE_SCRIPT) {
+ if (items.length != 2)
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect number of arguments to script";
+ var [testURI] = runHttp
+ ? ServeFiles(principal, httpDepth,
+ listURL, [items[1]])
+ : [gIOService.newURI(items[1], null, listURL)];
+ var prettyPath = runHttp
+ ? gIOService.newURI(items[1], null, listURL).spec
+ : testURI.spec;
+ secMan.checkLoadURIWithPrincipal(principal, testURI,
+ CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+ AddTestItem({ type: TYPE_SCRIPT,
+ expected: expected_status,
+ allowSilentFail: allow_silent_fail,
+ prettyPath: prettyPath,
+ minAsserts: minAsserts,
+ maxAsserts: maxAsserts,
+ needsFocus: needs_focus,
+ slow: slow,
+ prefSettings1: testPrefSettings,
+ prefSettings2: refPrefSettings,
+ fuzzyMaxDelta: fuzzy_max_delta,
+ fuzzyMaxPixels: fuzzy_max_pixels,
+ url1: testURI,
+ url2: null,
+ chaosMode: chaosMode }, aFilter);
+ } else if (items[0] == TYPE_REFTEST_EQUAL || items[0] == TYPE_REFTEST_NOTEQUAL) {
+ if (items.length != 3)
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect number of arguments to " + items[0];
+ var [testURI, refURI] = runHttp
+ ? ServeFiles(principal, httpDepth,
+ listURL, [items[1], items[2]])
+ : [gIOService.newURI(items[1], null, listURL),
+ gIOService.newURI(items[2], null, listURL)];
+ var prettyPath = runHttp
+ ? gIOService.newURI(items[1], null, listURL).spec
+ : testURI.spec;
+ secMan.checkLoadURIWithPrincipal(principal, testURI,
+ CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+ secMan.checkLoadURIWithPrincipal(principal, refURI,
+ CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+ AddTestItem({ type: items[0],
+ expected: expected_status,
+ allowSilentFail: allow_silent_fail,
+ prettyPath: prettyPath,
+ minAsserts: minAsserts,
+ maxAsserts: maxAsserts,
+ needsFocus: needs_focus,
+ slow: slow,
+ prefSettings1: testPrefSettings,
+ prefSettings2: refPrefSettings,
+ fuzzyMaxDelta: fuzzy_max_delta,
+ fuzzyMaxPixels: fuzzy_max_pixels,
+ url1: testURI,
+ url2: refURI,
+ chaosMode: chaosMode }, aFilter);
+ } else {
+ throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": unknown test type " + items[0];
+ }
+ }
+}
+
+function AddURIUseCount(uri)
+{
+ if (uri == null)
+ return;
+
+ var spec = uri.spec;
+ if (spec in gURIUseCounts) {
+ gURIUseCounts[spec]++;
+ } else {
+ gURIUseCounts[spec] = 1;
+ }
+}
+
+function BuildUseCounts()
+{
+ if (gNoCanvasCache) {
+ return;
+ }
+
+ gURIUseCounts = {};
+ for (var i = 0; i < gURLs.length; ++i) {
+ var url = gURLs[i];
+ if (url.expected != EXPECTED_DEATH &&
+ (url.type == TYPE_REFTEST_EQUAL ||
+ url.type == TYPE_REFTEST_NOTEQUAL)) {
+ if (url.prefSettings1.length == 0) {
+ AddURIUseCount(gURLs[i].url1);
+ }
+ if (url.prefSettings2.length == 0) {
+ AddURIUseCount(gURLs[i].url2);
+ }
+ }
+ }
+}
+
+function ServeFiles(manifestPrincipal, depth, aURL, files)
+{
+ var listURL = aURL.QueryInterface(CI.nsIFileURL);
+ var directory = listURL.file.parent;
+
+ // Allow serving a tree that's an ancestor of the directory containing
+ // the files so that they can use resources in ../ (etc.).
+ var dirPath = "/";
+ while (depth > 0) {
+ dirPath = "/" + directory.leafName + dirPath;
+ directory = directory.parent;
+ --depth;
+ }
+
+ gCount++;
+ var path = "/" + Date.now() + "/" + gCount;
+ gServer.registerDirectory(path + "/", directory);
+
+ var secMan = CC[NS_SCRIPTSECURITYMANAGER_CONTRACTID]
+ .getService(CI.nsIScriptSecurityManager);
+
+ var testbase = gIOService.newURI("http://localhost:" + gHttpServerPort +
+ path + dirPath, null, null);
+
+ // Give the testbase URI access to XUL and XBL
+ Services.perms.add(testbase, "allowXULXBL", Services.perms.ALLOW_ACTION);
+
+ function FileToURI(file)
+ {
+ // Only serve relative URIs via the HTTP server, not absolute
+ // ones like about:blank.
+ var testURI = gIOService.newURI(file, null, testbase);
+
+ // XXX necessary? manifestURL guaranteed to be file, others always HTTP
+ secMan.checkLoadURIWithPrincipal(manifestPrincipal, testURI,
+ CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+
+ return testURI;
+ }
+
+ return files.map(FileToURI);
+}
+
+// Return true iff this window is focused when this function returns.
+function Focus()
+{
+ var fm = CC["@mozilla.org/focus-manager;1"].getService(CI.nsIFocusManager);
+ fm.focusedWindow = gContainingWindow;
+#ifdef XP_MACOSX
+ try {
+ var dock = CC["@mozilla.org/widget/macdocksupport;1"].getService(CI.nsIMacDockSupport);
+ dock.activateApplication(true);
+ } catch(ex) {
+ }
+#endif // XP_MACOSX
+ return true;
+}
+
+function Blur()
+{
+ // On non-remote reftests, this will transfer focus to the dummy window
+ // we created to hold focus for non-needs-focus tests. Buggy tests
+ // (ones which require focus but don't request needs-focus) will then
+ // fail.
+ gContainingWindow.blur();
+}
+
+function StartCurrentTest()
+{
+ gTestLog = [];
+
+ // make sure we don't run tests that are expected to kill the browser
+ while (gURLs.length > 0) {
+ var test = gURLs[0];
+ logger.testStart(test.identifier);
+ if (test.expected == EXPECTED_DEATH) {
+ ++gTestResults.Skip;
+ logger.testEnd(test.identifier, "SKIP");
+ gURLs.shift();
+ } else if (test.needsFocus && !Focus()) {
+ // FIXME: Marking this as a known fail is dangerous! What
+ // if it starts failing all the time?
+ ++gTestResults.Skip;
+ logger.testEnd(test.identifier, "SKIP", null, "(COULDN'T GET FOCUS)");
+ gURLs.shift();
+ } else if (test.slow && !gRunSlowTests) {
+ ++gTestResults.Slow;
+ logger.testEnd(test.identifier, "SKIP", null, "(SLOW)");
+ gURLs.shift();
+ } else {
+ break;
+ }
+ }
+
+ if ((gURLs.length == 0 && gRepeat == 0) ||
+ (gRunUntilFailure && HasUnexpectedResult())) {
+ RestoreChangedPreferences();
+ DoneTests();
+ } else if (gURLs.length == 0 && gRepeat > 0) {
+ // Repeat
+ gRepeat--;
+ StartTests();
+ } else {
+ if (gURLs[0].chaosMode) {
+ gWindowUtils.enterChaosMode();
+ }
+ if (!gURLs[0].needsFocus) {
+ Blur();
+ }
+ var currentTest = gTotalTests - gURLs.length;
+ gContainingWindow.document.title = "reftest: " + currentTest + " / " + gTotalTests +
+ " (" + Math.floor(100 * (currentTest / gTotalTests)) + "%)";
+ StartCurrentURI(1);
+ }
+}
+
+function StartCurrentURI(aState)
+{
+ gState = aState;
+ gCurrentURL = gURLs[0]["url" + aState].spec;
+
+ RestoreChangedPreferences();
+
+ var prefSettings = gURLs[0]["prefSettings" + aState];
+ if (prefSettings.length > 0) {
+ var prefs = Components.classes["@mozilla.org/preferences-service;1"].
+ getService(Components.interfaces.nsIPrefBranch);
+ var badPref = undefined;
+ try {
+ prefSettings.forEach(function(ps) {
+ var oldVal;
+ if (ps.type == PREF_BOOLEAN) {
+ try {
+ oldVal = prefs.getBoolPref(ps.name);
+ } catch (e) {
+ badPref = "boolean preference '" + ps.name + "'";
+ throw "bad pref";
+ }
+ } else if (ps.type == PREF_STRING) {
+ try {
+ oldVal = prefs.getCharPref(ps.name);
+ } catch (e) {
+ badPref = "string preference '" + ps.name + "'";
+ throw "bad pref";
+ }
+ } else if (ps.type == PREF_INTEGER) {
+ try {
+ oldVal = prefs.getIntPref(ps.name);
+ } catch (e) {
+ badPref = "integer preference '" + ps.name + "'";
+ throw "bad pref";
+ }
+ } else {
+ throw "internal error - unknown preference type";
+ }
+ if (oldVal != ps.value) {
+ gPrefsToRestore.push( { name: ps.name,
+ type: ps.type,
+ value: oldVal } );
+ var value = ps.value;
+ if (ps.type == PREF_BOOLEAN) {
+ prefs.setBoolPref(ps.name, value);
+ } else if (ps.type == PREF_STRING) {
+ prefs.setCharPref(ps.name, value);
+ value = '"' + value + '"';
+ } else if (ps.type == PREF_INTEGER) {
+ prefs.setIntPref(ps.name, value);
+ }
+ logger.info("SET PREFERENCE pref(" + ps.name + "," + value + ")");
+ }
+ });
+ } catch (e) {
+ if (e == "bad pref") {
+ var test = gURLs[0];
+ if (test.expected == EXPECTED_FAIL) {
+ logger.testEnd(test.identifier, "FAIL", "FAIL",
+ "(SKIPPED; " + badPref + " not known or wrong type)");
+ ++gTestResults.Skip;
+ } else {
+ logger.testEnd(test.identifier, "FAIL", "PASS",
+ badPref + " not known or wrong type");
+ ++gTestResults.UnexpectedFail;
+ }
+
+ // skip the test that had a bad preference
+ gURLs.shift();
+ StartCurrentTest();
+ return;
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ if (prefSettings.length == 0 &&
+ gURICanvases[gCurrentURL] &&
+ (gURLs[0].type == TYPE_REFTEST_EQUAL ||
+ gURLs[0].type == TYPE_REFTEST_NOTEQUAL) &&
+ gURLs[0].maxAsserts == 0) {
+ // Pretend the document loaded --- RecordResult will notice
+ // there's already a canvas for this URL
+ gContainingWindow.setTimeout(RecordResult, 0);
+ } else {
+ var currentTest = gTotalTests - gURLs.length;
+ // Log this to preserve the same overall log format,
+ // should be removed if the format is updated
+ gDumpFn("REFTEST TEST-LOAD | " + gCurrentURL + " | " + currentTest + " / " + gTotalTests +
+ " (" + Math.floor(100 * (currentTest / gTotalTests)) + "%)\n");
+ TestBuffer("START " + gCurrentURL);
+ var type = gURLs[0].type
+ if (TYPE_SCRIPT == type) {
+ SendLoadScriptTest(gCurrentURL, gLoadTimeout);
+ } else {
+ SendLoadTest(type, gCurrentURL, gLoadTimeout);
+ }
+ }
+}
+
+function DoneTests()
+{
+ logger.suiteEnd(extra={'results': gTestResults});
+ logger.info("Slowest test took " + gSlowestTestTime + "ms (" + gSlowestTestURL + ")");
+ logger.info("Total canvas count = " + gRecycledCanvases.length);
+ if (gFailedUseWidgetLayers) {
+ LogWidgetLayersFailure();
+ }
+
+ function onStopped() {
+ let appStartup = CC["@mozilla.org/toolkit/app-startup;1"].getService(CI.nsIAppStartup);
+ appStartup.quit(CI.nsIAppStartup.eForceQuit);
+ }
+ if (gServer) {
+ gServer.stop(onStopped);
+ }
+ else {
+ onStopped();
+ }
+}
+
+function UpdateCanvasCache(url, canvas)
+{
+ var spec = url.spec;
+
+ --gURIUseCounts[spec];
+
+ if (gURIUseCounts[spec] == 0) {
+ ReleaseCanvas(canvas);
+ delete gURICanvases[spec];
+ } else if (gURIUseCounts[spec] > 0) {
+ gURICanvases[spec] = canvas;
+ } else {
+ throw "Use counts were computed incorrectly";
+ }
+}
+
+// Recompute drawWindow flags for every drawWindow operation.
+// We have to do this every time since our window can be
+// asynchronously resized (e.g. by the window manager, to make
+// it fit on screen) at unpredictable times.
+// Fortunately this is pretty cheap.
+function DoDrawWindow(ctx, x, y, w, h)
+{
+ var flags = ctx.DRAWWINDOW_DRAW_CARET | ctx.DRAWWINDOW_DRAW_VIEW;
+ var testRect = gBrowser.getBoundingClientRect();
+ if (gIgnoreWindowSize ||
+ (0 <= testRect.left &&
+ 0 <= testRect.top &&
+ gContainingWindow.innerWidth >= testRect.right &&
+ gContainingWindow.innerHeight >= testRect.bottom)) {
+ // We can use the window's retained layer manager
+ // because the window is big enough to display the entire
+ // browser element
+ flags |= ctx.DRAWWINDOW_USE_WIDGET_LAYERS;
+ } else if (gBrowserIsRemote) {
+ logger.error(gCurrentURL + " | can't drawWindow remote content");
+ ++gTestResults.Exception;
+ }
+
+ if (gDrawWindowFlags != flags) {
+ // Every time the flags change, dump the new state.
+ gDrawWindowFlags = flags;
+ var flagsStr = "DRAWWINDOW_DRAW_CARET | DRAWWINDOW_DRAW_VIEW";
+ if (flags & ctx.DRAWWINDOW_USE_WIDGET_LAYERS) {
+ flagsStr += " | DRAWWINDOW_USE_WIDGET_LAYERS";
+ } else {
+ // Output a special warning because we need to be able to detect
+ // this whenever it happens.
+ LogWidgetLayersFailure();
+ gFailedUseWidgetLayers = true;
+ }
+ logger.info("drawWindow flags = " + flagsStr +
+ "; window size = " + gContainingWindow.innerWidth + "," + gContainingWindow.innerHeight +
+ "; test browser size = " + testRect.width + "," + testRect.height);
+ }
+
+ TestBuffer("DoDrawWindow " + x + "," + y + "," + w + "," + h);
+ ctx.drawWindow(gContainingWindow, x, y, w, h, "rgb(255,255,255)",
+ gDrawWindowFlags);
+}
+
+function InitCurrentCanvasWithSnapshot()
+{
+ TestBuffer("Initializing canvas snapshot");
+
+ if (gURLs[0].type == TYPE_LOAD || gURLs[0].type == TYPE_SCRIPT) {
+ // We don't want to snapshot this kind of test
+ return false;
+ }
+
+ if (!gCurrentCanvas) {
+ gCurrentCanvas = AllocateCanvas();
+ }
+
+ var ctx = gCurrentCanvas.getContext("2d");
+ DoDrawWindow(ctx, 0, 0, gCurrentCanvas.width, gCurrentCanvas.height);
+ return true;
+}
+
+function UpdateCurrentCanvasForInvalidation(rects)
+{
+ TestBuffer("Updating canvas for invalidation");
+
+ if (!gCurrentCanvas) {
+ return;
+ }
+
+ var ctx = gCurrentCanvas.getContext("2d");
+ for (var i = 0; i < rects.length; ++i) {
+ var r = rects[i];
+ // Set left/top/right/bottom to pixel boundaries
+ var left = Math.floor(r.left);
+ var top = Math.floor(r.top);
+ var right = Math.ceil(r.right);
+ var bottom = Math.ceil(r.bottom);
+
+ // Clamp the values to the canvas size
+ left = Math.max(0, Math.min(left, gCurrentCanvas.width));
+ top = Math.max(0, Math.min(top, gCurrentCanvas.height));
+ right = Math.max(0, Math.min(right, gCurrentCanvas.width));
+ bottom = Math.max(0, Math.min(bottom, gCurrentCanvas.height));
+
+ ctx.save();
+ ctx.translate(left, top);
+ DoDrawWindow(ctx, left, top, right - left, bottom - top);
+ ctx.restore();
+ }
+}
+
+function UpdateWholeCurrentCanvasForInvalidation()
+{
+ TestBuffer("Updating entire canvas for invalidation");
+
+ if (!gCurrentCanvas) {
+ return;
+ }
+
+ var ctx = gCurrentCanvas.getContext("2d");
+ DoDrawWindow(ctx, 0, 0, gCurrentCanvas.width, gCurrentCanvas.height);
+}
+
+function RecordResult(testRunTime, errorMsg, scriptResults)
+{
+ TestBuffer("RecordResult fired");
+
+ // Keep track of which test was slowest, and how long it took.
+ if (testRunTime > gSlowestTestTime) {
+ gSlowestTestTime = testRunTime;
+ gSlowestTestURL = gCurrentURL;
+ }
+
+ // Not 'const ...' because of 'EXPECTED_*' value dependency.
+ var outputs = {};
+ outputs[EXPECTED_PASS] = {
+ true: {s: ["PASS", "PASS"], n: "Pass"},
+ false: {s: ["FAIL", "PASS"], n: "UnexpectedFail"}
+ };
+ outputs[EXPECTED_FAIL] = {
+ true: {s: ["PASS", "FAIL"], n: "UnexpectedPass"},
+ false: {s: ["FAIL", "FAIL"], n: "KnownFail"}
+ };
+ outputs[EXPECTED_RANDOM] = {
+ true: {s: ["PASS", "PASS"], n: "Random"},
+ false: {s: ["FAIL", "FAIL"], n: "Random"}
+ };
+ outputs[EXPECTED_FUZZY] = outputs[EXPECTED_PASS];
+
+ var output;
+ var extra;
+
+ if (gURLs[0].type == TYPE_LOAD) {
+ ++gTestResults.LoadOnly;
+ logger.testEnd(gURLs[0].identifier, "PASS", "PASS", "(LOAD ONLY)");
+ gCurrentCanvas = null;
+ FinishTestItem();
+ return;
+ }
+ if (gURLs[0].type == TYPE_SCRIPT) {
+ var expected = gURLs[0].expected;
+
+ if (errorMsg) {
+ // Force an unexpected failure to alert the test author to fix the test.
+ expected = EXPECTED_PASS;
+ } else if (scriptResults.length == 0) {
+ // This failure may be due to a JavaScript Engine bug causing
+ // early termination of the test. If we do not allow silent
+ // failure, report an error.
+ if (!gURLs[0].allowSilentFail)
+ errorMsg = "No test results reported. (SCRIPT)\n";
+ else
+ logger.info("An expected silent failure occurred");
+ }
+
+ if (errorMsg) {
+ output = outputs[expected][false];
+ extra = { status_msg: output.n };
+ ++gTestResults[output.n];
+ logger.testEnd(gURLs[0].identifier, output.s[0], output.s[1], errorMsg, null, extra);
+ FinishTestItem();
+ return;
+ }
+
+ var anyFailed = scriptResults.some(function(result) { return !result.passed; });
+ var outputPair;
+ if (anyFailed && expected == EXPECTED_FAIL) {
+ // If we're marked as expected to fail, and some (but not all) tests
+ // passed, treat those tests as though they were marked random
+ // (since we can't tell whether they were really intended to be
+ // marked failing or not).
+ outputPair = { true: outputs[EXPECTED_RANDOM][true],
+ false: outputs[expected][false] };
+ } else {
+ outputPair = outputs[expected];
+ }
+ var index = 0;
+ scriptResults.forEach(function(result) {
+ var output = outputPair[result.passed];
+ var extra = { status_msg: output.n };
+
+ ++gTestResults[output.n];
+ logger.testEnd(gURLs[0].identifier, output.s[0], output.s[1],
+ result.description + " item " + (++index), null, extra);
+ });
+
+ if (anyFailed && expected == EXPECTED_PASS) {
+ FlushTestBuffer();
+ }
+
+ FinishTestItem();
+ return;
+ }
+
+ if (gURLs[0]["prefSettings" + gState].length == 0 &&
+ gURICanvases[gCurrentURL]) {
+ gCurrentCanvas = gURICanvases[gCurrentURL];
+ }
+ if (gCurrentCanvas == null) {
+ logger.error(gCurrentURL, "program error managing snapshots");
+ ++gTestResults.Exception;
+ }
+ if (gState == 1) {
+ gCanvas1 = gCurrentCanvas;
+ } else {
+ gCanvas2 = gCurrentCanvas;
+ }
+ gCurrentCanvas = null;
+
+ ResetRenderingState();
+
+ switch (gState) {
+ case 1:
+ // First document has been loaded.
+ // Proceed to load the second document.
+
+ CleanUpCrashDumpFiles();
+ StartCurrentURI(2);
+ break;
+ case 2:
+ // Both documents have been loaded. Compare the renderings and see
+ // if the comparison result matches the expected result specified
+ // in the manifest.
+
+ // number of different pixels
+ var differences;
+ // whether the two renderings match:
+ var equal;
+ var maxDifference = {};
+
+ differences = gWindowUtils.compareCanvases(gCanvas1, gCanvas2, maxDifference);
+ equal = (differences == 0);
+
+ // what is expected on this platform (PASS, FAIL, or RANDOM)
+ var expected = gURLs[0].expected;
+
+ if (maxDifference.value > 0 && maxDifference.value <= gURLs[0].fuzzyMaxDelta &&
+ differences <= gURLs[0].fuzzyMaxPixels) {
+ if (equal) {
+ throw "Inconsistent result from compareCanvases.";
+ }
+ equal = expected == EXPECTED_FUZZY;
+ logger.info("REFTEST fuzzy match");
+ }
+
+ var failedExtraCheck = gFailedNoPaint || gFailedOpaqueLayer || gFailedAssignedLayer;
+
+ // whether the comparison result matches what is in the manifest
+ var test_passed = (equal == (gURLs[0].type == TYPE_REFTEST_EQUAL)) && !failedExtraCheck;
+
+ output = outputs[expected][test_passed];
+ extra = { status_msg: output.n };
+
+ ++gTestResults[output.n];
+
+ // It's possible that we failed both an "extra check" and the normal comparison, but we don't
+ // have a way to annotate these separately, so just print an error for the extra check failures.
+ if (failedExtraCheck) {
+ var failures = [];
+ if (gFailedNoPaint) {
+ failures.push("failed reftest-no-paint");
+ }
+ // The gFailed*Messages arrays will contain messages from both the test and the reference.
+ if (gFailedOpaqueLayer) {
+ failures.push("failed reftest-opaque-layer: " + gFailedOpaqueLayerMessages.join(", "));
+ }
+ if (gFailedAssignedLayer) {
+ failures.push("failed reftest-assigned-layer: " + gFailedAssignedLayerMessages.join(", "));
+ }
+ var failureString = failures.join(", ");
+ logger.testEnd(gURLs[0].identifier, output.s[0], output.s[1], failureString, null, extra);
+ } else {
+ var message = "image comparison";
+ if (!test_passed && expected == EXPECTED_PASS ||
+ !test_passed && expected == EXPECTED_FUZZY ||
+ test_passed && expected == EXPECTED_FAIL) {
+ if (!equal) {
+ extra.max_difference = maxDifference.value;
+ extra.differences = differences;
+ var image1 = gCanvas1.toDataURL();
+ var image2 = gCanvas2.toDataURL();
+ extra.reftest_screenshots = [
+ {url:gURLs[0].identifier[0],
+ screenshot: image1.slice(image1.indexOf(",") + 1)},
+ gURLs[0].identifier[1],
+ {url:gURLs[0].identifier[2],
+ screenshot: image2.slice(image2.indexOf(",") + 1)}
+ ];
+ extra.image1 = image1;
+ extra.image2 = image2;
+ message += (", max difference: " + extra.max_difference +
+ ", number of differing pixels: " + differences);
+ } else {
+ extra.image1 = gCanvas1.toDataURL();
+ }
+ }
+ logger.testEnd(gURLs[0].identifier, output.s[0], output.s[1], message, null, extra);
+
+ if (gNoCanvasCache) {
+ ReleaseCanvas(gCanvas1);
+ ReleaseCanvas(gCanvas2);
+ } else {
+ if (gURLs[0].prefSettings1.length == 0) {
+ UpdateCanvasCache(gURLs[0].url1, gCanvas1);
+ }
+ if (gURLs[0].prefSettings2.length == 0) {
+ UpdateCanvasCache(gURLs[0].url2, gCanvas2);
+ }
+ }
+ }
+
+ if ((!test_passed && expected == EXPECTED_PASS) || (test_passed && expected == EXPECTED_FAIL)) {
+ FlushTestBuffer();
+ }
+
+ CleanUpCrashDumpFiles();
+ FinishTestItem();
+ break;
+ default:
+ throw "Unexpected state.";
+ }
+}
+
+function LoadFailed(why)
+{
+ ++gTestResults.FailedLoad;
+ // Once bug 896840 is fixed, this can go away, but for now it will give log
+ // output that is TBPL starable for bug 789751 and bug 720452.
+ if (!why) {
+ logger.error("load failed with unknown reason");
+ }
+ logger.testEnd(gURLs[0]["url" + gState].spec, "FAIL", "PASS", "load failed: " + why);
+ FlushTestBuffer();
+ FinishTestItem();
+}
+
+function RemoveExpectedCrashDumpFiles()
+{
+ if (gExpectingProcessCrash) {
+ for (let crashFilename of gExpectedCrashDumpFiles) {
+ let file = gCrashDumpDir.clone();
+ file.append(crashFilename);
+ if (file.exists()) {
+ file.remove(false);
+ }
+ }
+ }
+ gExpectedCrashDumpFiles.length = 0;
+}
+
+function FindUnexpectedCrashDumpFiles()
+{
+ if (!gCrashDumpDir.exists()) {
+ return;
+ }
+
+ let entries = gCrashDumpDir.directoryEntries;
+ if (!entries) {
+ return;
+ }
+
+ let foundCrashDumpFile = false;
+ while (entries.hasMoreElements()) {
+ let file = entries.getNext().QueryInterface(CI.nsIFile);
+ let path = String(file.path);
+ if (path.match(/\.(dmp|extra)$/) && !gUnexpectedCrashDumpFiles[path]) {
+ if (!foundCrashDumpFile) {
+ ++gTestResults.UnexpectedFail;
+ foundCrashDumpFile = true;
+ logger.testEnd(gCurrentURL, "FAIL", "PASS", "This test left crash dumps behind, but we weren't expecting it to!");
+ }
+ logger.info("Found unexpected crash dump file " + path);
+ gUnexpectedCrashDumpFiles[path] = true;
+ }
+ }
+}
+
+function CleanUpCrashDumpFiles()
+{
+ RemoveExpectedCrashDumpFiles();
+ FindUnexpectedCrashDumpFiles();
+ gExpectingProcessCrash = false;
+}
+
+function FinishTestItem()
+{
+ // Replace document with BLANK_URL_FOR_CLEARING in case there are
+ // assertions when unloading.
+ logger.debug("Loading a blank page");
+ // After clearing, content will notify us of the assertion count
+ // and tests will continue.
+ SendClear();
+ gFailedNoPaint = false;
+ gFailedOpaqueLayer = false;
+ gFailedOpaqueLayerMessages = [];
+ gFailedAssignedLayer = false;
+ gFailedAssignedLayerMessages = [];
+}
+
+function DoAssertionCheck(numAsserts)
+{
+ if (gDebug.isDebugBuild) {
+ if (gBrowserIsRemote) {
+ // Count chrome-process asserts too when content is out of
+ // process.
+ var newAssertionCount = gDebug.assertionCount;
+ var numLocalAsserts = newAssertionCount - gAssertionCount;
+ gAssertionCount = newAssertionCount;
+
+ numAsserts += numLocalAsserts;
+ }
+
+ var minAsserts = gURLs[0].minAsserts;
+ var maxAsserts = gURLs[0].maxAsserts;
+
+ var expectedAssertions = "expected " + minAsserts;
+ if (minAsserts != maxAsserts) {
+ expectedAssertions += " to " + maxAsserts;
+ }
+ expectedAssertions += " assertions";
+
+ if (numAsserts < minAsserts) {
+ ++gTestResults.AssertionUnexpectedFixed;
+ gDumpFn("REFTEST TEST-UNEXPECTED-PASS | " + gURLs[0].prettyPath +
+ " | assertion count " + numAsserts + " is less than " +
+ expectedAssertions + "\n");
+ } else if (numAsserts > maxAsserts) {
+ ++gTestResults.AssertionUnexpected;
+ gDumpFn("REFTEST TEST-UNEXPECTED-FAIL | " + gURLs[0].prettyPath +
+ " | assertion count " + numAsserts + " is more than " +
+ expectedAssertions + "\n");
+ } else if (numAsserts != 0) {
+ ++gTestResults.AssertionKnown;
+ gDumpFn("REFTEST TEST-KNOWN-FAIL | " + gURLs[0].prettyPath +
+ "assertion count " + numAsserts + " matches " +
+ expectedAssertions + "\n");
+ }
+ }
+
+ if (gURLs[0].chaosMode) {
+ gWindowUtils.leaveChaosMode();
+ }
+
+ // And start the next test.
+ gURLs.shift();
+ StartCurrentTest();
+}
+
+function ResetRenderingState()
+{
+ SendResetRenderingState();
+ // We would want to clear any viewconfig here, if we add support for it
+}
+
+function RestoreChangedPreferences()
+{
+ if (gPrefsToRestore.length > 0) {
+ var prefs = Components.classes["@mozilla.org/preferences-service;1"].
+ getService(Components.interfaces.nsIPrefBranch);
+ gPrefsToRestore.reverse();
+ gPrefsToRestore.forEach(function(ps) {
+ var value = ps.value;
+ if (ps.type == PREF_BOOLEAN) {
+ prefs.setBoolPref(ps.name, value);
+ } else if (ps.type == PREF_STRING) {
+ prefs.setCharPref(ps.name, value);
+ value = '"' + value + '"';
+ } else if (ps.type == PREF_INTEGER) {
+ prefs.setIntPref(ps.name, value);
+ }
+ logger.info("RESTORE PREFERENCE pref(" + ps.name + "," + value + ")");
+ });
+ gPrefsToRestore = [];
+ }
+}
+
+function RegisterMessageListenersAndLoadContentScript()
+{
+ gBrowserMessageManager.addMessageListener(
+ "reftest:AssertionCount",
+ function (m) { RecvAssertionCount(m.json.count); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:ContentReady",
+ function (m) { return RecvContentReady(m.data); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:Exception",
+ function (m) { RecvException(m.json.what) }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:FailedLoad",
+ function (m) { RecvFailedLoad(m.json.why); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:FailedNoPaint",
+ function (m) { RecvFailedNoPaint(); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:FailedOpaqueLayer",
+ function (m) { RecvFailedOpaqueLayer(m.json.why); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:FailedAssignedLayer",
+ function (m) { RecvFailedAssignedLayer(m.json.why); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:InitCanvasWithSnapshot",
+ function (m) { return RecvInitCanvasWithSnapshot(); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:Log",
+ function (m) { RecvLog(m.json.type, m.json.msg); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:ScriptResults",
+ function (m) { RecvScriptResults(m.json.runtimeMs, m.json.error, m.json.results); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:TestDone",
+ function (m) { RecvTestDone(m.json.runtimeMs); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:UpdateCanvasForInvalidation",
+ function (m) { RecvUpdateCanvasForInvalidation(m.json.rects); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:UpdateWholeCanvasForInvalidation",
+ function (m) { RecvUpdateWholeCanvasForInvalidation(); }
+ );
+ gBrowserMessageManager.addMessageListener(
+ "reftest:ExpectProcessCrash",
+ function (m) { RecvExpectProcessCrash(); }
+ );
+
+ gBrowserMessageManager.loadFrameScript("chrome://reftest/content/reftest-content.js", true, true);
+}
+
+function RecvAssertionCount(count)
+{
+ DoAssertionCheck(count);
+}
+
+function RecvContentReady(info)
+{
+ gContentGfxInfo = info.gfx;
+ InitAndStartRefTests();
+ return { remote: gBrowserIsRemote };
+}
+
+function RecvException(what)
+{
+ logger.error(gCurrentURL + " | " + what);
+ ++gTestResults.Exception;
+}
+
+function RecvFailedLoad(why)
+{
+ LoadFailed(why);
+}
+
+function RecvFailedNoPaint()
+{
+ gFailedNoPaint = true;
+}
+
+function RecvFailedOpaqueLayer(why) {
+ gFailedOpaqueLayer = true;
+ gFailedOpaqueLayerMessages.push(why);
+}
+
+function RecvFailedAssignedLayer(why) {
+ gFailedAssignedLayer = true;
+ gFailedAssignedLayerMessages.push(why);
+}
+
+function RecvInitCanvasWithSnapshot()
+{
+ var painted = InitCurrentCanvasWithSnapshot();
+ return { painted: painted };
+}
+
+function RecvLog(type, msg)
+{
+ msg = "[CONTENT] " + msg;
+ if (type == "info") {
+ TestBuffer(msg);
+ } else if (type == "warning") {
+ logger.warning(msg);
+ } else {
+ logger.error("REFTEST TEST-UNEXPECTED-FAIL | " + gCurrentURL + " | unknown log type " + type + "\n");
+ ++gTestResults.Exception;
+ }
+}
+
+function RecvScriptResults(runtimeMs, error, results)
+{
+ RecordResult(runtimeMs, error, results);
+}
+
+function RecvTestDone(runtimeMs)
+{
+ RecordResult(runtimeMs, '', [ ]);
+}
+
+function RecvUpdateCanvasForInvalidation(rects)
+{
+ UpdateCurrentCanvasForInvalidation(rects);
+}
+
+function RecvUpdateWholeCanvasForInvalidation()
+{
+ UpdateWholeCurrentCanvasForInvalidation();
+}
+
+function OnProcessCrashed(subject, topic, data)
+{
+ var id;
+ subject = subject.QueryInterface(CI.nsIPropertyBag2);
+ if (topic == "plugin-crashed") {
+ id = subject.getPropertyAsAString("pluginDumpID");
+ } else if (topic == "ipc:content-shutdown") {
+ id = subject.getPropertyAsAString("dumpID");
+ }
+ if (id) {
+ gExpectedCrashDumpFiles.push(id + ".dmp");
+ gExpectedCrashDumpFiles.push(id + ".extra");
+ }
+}
+
+function RegisterProcessCrashObservers()
+{
+ var os = CC[NS_OBSERVER_SERVICE_CONTRACTID]
+ .getService(CI.nsIObserverService);
+ os.addObserver(OnProcessCrashed, "plugin-crashed", false);
+ os.addObserver(OnProcessCrashed, "ipc:content-shutdown", false);
+}
+
+function RecvExpectProcessCrash()
+{
+ gExpectingProcessCrash = true;
+}
+
+function SendClear()
+{
+ gBrowserMessageManager.sendAsyncMessage("reftest:Clear");
+}
+
+function SendLoadScriptTest(uri, timeout)
+{
+ gBrowserMessageManager.sendAsyncMessage("reftest:LoadScriptTest",
+ { uri: uri, timeout: timeout });
+}
+
+function SendLoadTest(type, uri, timeout)
+{
+ gBrowserMessageManager.sendAsyncMessage("reftest:LoadTest",
+ { type: type, uri: uri, timeout: timeout }
+ );
+}
+
+function SendResetRenderingState()
+{
+ gBrowserMessageManager.sendAsyncMessage("reftest:ResetRenderingState");
+}