2015-06-16 22:49:26 +00:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
const { utils: Cu, interfaces: Ci, classes: Cc, results: Cr } = Components;
|
|
|
|
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
|
|
Cu.import('resource://gre/modules/Preferences.jsm');
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
|
2015-07-08 20:00:17 +00:00
|
|
|
const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
|
|
|
|
const FRAME_SCRIPT_URL = "chrome://gfxsanity/content/gfxFrameScript.js";
|
|
|
|
|
|
|
|
const PAGE_WIDTH=92;
|
|
|
|
const PAGE_HEIGHT=166;
|
2015-06-16 22:49:26 +00:00
|
|
|
const DRIVER_PREF="sanity-test.driver-version";
|
|
|
|
const DEVICE_PREF="sanity-test.device-id";
|
|
|
|
const VERSION_PREF="sanity-test.version";
|
|
|
|
const DISABLE_VIDEO_PREF="media.hardware-video-decoding.failed";
|
|
|
|
const RUNNING_PREF="sanity-test.running";
|
2015-06-18 20:44:04 +00:00
|
|
|
const OS_SNAPSHOT_TIMEOUT_SEC=3;
|
2015-06-16 22:49:26 +00:00
|
|
|
|
|
|
|
// GRAPHICS_SANITY_TEST histogram enumeration values
|
|
|
|
const TEST_PASSED=0;
|
|
|
|
const TEST_FAILED_RENDER=1;
|
|
|
|
const TEST_FAILED_VIDEO=2;
|
|
|
|
const TEST_CRASHED=3;
|
|
|
|
|
2015-06-18 20:44:04 +00:00
|
|
|
// GRAPHICS_SANITY_TEST_OS_SNAPSHOT histogram enumeration values
|
2015-06-29 19:41:59 +00:00
|
|
|
const SNAPSHOT_VIDEO_OK=0;
|
|
|
|
const SNAPSHOT_VIDEO_FAIL=1;
|
2015-06-18 20:44:04 +00:00
|
|
|
const SNAPSHOT_ERROR=2;
|
|
|
|
const SNAPSHOT_TIMEOUT=3;
|
2015-06-29 19:41:59 +00:00
|
|
|
const SNAPSHOT_LAYERS_OK=4;
|
|
|
|
const SNAPSHOT_LAYERS_FAIL=5;
|
2015-06-18 20:44:04 +00:00
|
|
|
|
2015-06-16 22:49:26 +00:00
|
|
|
function testPixel(ctx, x, y, r, g, b, a, fuzz) {
|
|
|
|
var data = ctx.getImageData(x, y, 1, 1);
|
|
|
|
|
|
|
|
if (Math.abs(data.data[0] - r) <= fuzz &&
|
|
|
|
Math.abs(data.data[1] - g) <= fuzz &&
|
|
|
|
Math.abs(data.data[2] - b) <= fuzz &&
|
|
|
|
Math.abs(data.data[3] - a) <= fuzz) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
function reportResult(val) {
|
|
|
|
try {
|
|
|
|
let histogram = Services.telemetry.getHistogramById("GRAPHICS_SANITY_TEST");
|
|
|
|
histogram.add(val);
|
|
|
|
} catch (e) {}
|
|
|
|
|
|
|
|
Preferences.set(RUNNING_PREF, false);
|
|
|
|
Services.prefs.savePrefFile(null);
|
|
|
|
}
|
|
|
|
|
2015-06-18 20:44:04 +00:00
|
|
|
function reportSnapshotResult(val) {
|
|
|
|
let histogram = Services.telemetry.getHistogramById("GRAPHICS_SANITY_TEST_OS_SNAPSHOT");
|
|
|
|
histogram.add(val);
|
|
|
|
}
|
|
|
|
|
2015-06-18 20:42:35 +00:00
|
|
|
function takeWindowSnapshot(win, ctx) {
|
2015-06-16 22:49:26 +00:00
|
|
|
// TODO: drawWindow reads back from the gpu's backbuffer, which won't catch issues with presenting
|
|
|
|
// the front buffer via the window manager. Ideally we'd use an OS level API for reading back
|
|
|
|
// from the desktop itself to get a more accurate test.
|
|
|
|
var flags = ctx.DRAWWINDOW_DRAW_CARET | ctx.DRAWWINDOW_DRAW_VIEW | ctx.DRAWWINDOW_USE_WIDGET_LAYERS;
|
|
|
|
ctx.drawWindow(win.ownerGlobal, 0, 0, PAGE_WIDTH, PAGE_HEIGHT, "rgb(255,255,255)", flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify that all the 4 coloured squares of the video
|
|
|
|
// render as expected (with a tolerance of 64 to allow for
|
|
|
|
// yuv->rgb differences between platforms).
|
|
|
|
//
|
|
|
|
// The video is 64x64, and is split into quadrants of
|
|
|
|
// different colours. The top left of the video is 8,72
|
|
|
|
// and we test a pixel 10,10 into each quadrant to avoid
|
|
|
|
// blending differences at the edges.
|
|
|
|
//
|
|
|
|
// We allow massive amounts of fuzz for the colours since
|
|
|
|
// it can depend hugely on the yuv -> rgb conversion, and
|
|
|
|
// we don't want to fail unnecessarily.
|
|
|
|
function verifyVideoRendering(ctx) {
|
|
|
|
return testPixel(ctx, 18, 82, 255, 255, 255, 255, 64) &&
|
|
|
|
testPixel(ctx, 50, 82, 0, 255, 0, 255, 64) &&
|
|
|
|
testPixel(ctx, 18, 114, 0, 0, 255, 255, 64) &&
|
|
|
|
testPixel(ctx, 50, 114, 255, 0, 0, 255, 64);
|
|
|
|
}
|
|
|
|
|
2015-06-29 19:41:59 +00:00
|
|
|
// Verify that the middle of the layers test is the color we expect.
|
|
|
|
// It's a red 64x64 square, test a pixel deep into the 64x64 square
|
|
|
|
// to prevent fuzzing.
|
|
|
|
function verifyLayersRendering(ctx) {
|
|
|
|
return testPixel(ctx, 18, 18, 255, 0, 0, 255, 64);
|
|
|
|
}
|
|
|
|
|
2015-06-18 20:42:35 +00:00
|
|
|
function testCompositor(win, ctx) {
|
|
|
|
takeWindowSnapshot(win, ctx);
|
2015-07-08 20:00:17 +00:00
|
|
|
var testPassed = true;
|
2015-06-16 22:49:26 +00:00
|
|
|
|
2015-06-18 20:42:35 +00:00
|
|
|
if (!verifyVideoRendering(ctx)) {
|
2015-06-16 22:49:26 +00:00
|
|
|
reportResult(TEST_FAILED_VIDEO);
|
|
|
|
Preferences.set(DISABLE_VIDEO_PREF, true);
|
2015-07-08 20:00:17 +00:00
|
|
|
testPassed = false;
|
2015-06-16 22:49:26 +00:00
|
|
|
}
|
2015-06-18 20:42:35 +00:00
|
|
|
|
2015-06-29 19:41:59 +00:00
|
|
|
if (!verifyLayersRendering(ctx)) {
|
|
|
|
reportResult(TEST_FAILED_RENDER);
|
2015-07-08 20:00:17 +00:00
|
|
|
testPassed = false;
|
2015-06-29 19:41:59 +00:00
|
|
|
}
|
|
|
|
|
2015-07-08 20:00:17 +00:00
|
|
|
if (testPassed) {
|
|
|
|
reportResult(TEST_PASSED);
|
|
|
|
}
|
|
|
|
|
|
|
|
return testPassed;
|
2015-06-16 22:49:26 +00:00
|
|
|
}
|
|
|
|
|
2015-06-18 20:42:35 +00:00
|
|
|
let listener = {
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]),
|
|
|
|
|
|
|
|
win: null,
|
2015-06-18 20:44:04 +00:00
|
|
|
utils: null,
|
2015-06-18 20:42:35 +00:00
|
|
|
canvas: null,
|
2015-07-08 20:00:17 +00:00
|
|
|
mm: null,
|
|
|
|
|
|
|
|
messages: [
|
|
|
|
"gfxSanity:ContentLoaded",
|
|
|
|
],
|
2015-06-18 20:42:35 +00:00
|
|
|
|
|
|
|
scheduleTest: function(win) {
|
|
|
|
this.win = win;
|
|
|
|
this.win.onload = this.onWindowLoaded.bind(this);
|
2015-06-18 20:44:04 +00:00
|
|
|
this.utils = this.win.QueryInterface(Ci.nsIInterfaceRequestor)
|
|
|
|
.getInterface(Ci.nsIDOMWindowUtils);
|
2015-06-18 20:42:35 +00:00
|
|
|
},
|
|
|
|
|
2015-07-08 20:00:17 +00:00
|
|
|
runSanityTest: function() {
|
2015-06-18 20:42:35 +00:00
|
|
|
this.canvas = this.win.document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
|
|
|
|
this.canvas.setAttribute("width", PAGE_WIDTH);
|
|
|
|
this.canvas.setAttribute("height", PAGE_HEIGHT);
|
|
|
|
this.ctx = this.canvas.getContext("2d");
|
|
|
|
|
2015-06-18 20:44:04 +00:00
|
|
|
// Perform the compositor backbuffer test, which currently we use for
|
|
|
|
// actually deciding whether to enable hardware media decoding.
|
2015-07-02 19:47:10 +00:00
|
|
|
testCompositor(this.win, this.ctx);
|
2015-07-08 20:00:17 +00:00
|
|
|
|
2015-06-18 20:44:04 +00:00
|
|
|
this.endTest();
|
2015-06-18 20:42:35 +00:00
|
|
|
},
|
2015-06-18 20:44:04 +00:00
|
|
|
|
2015-07-08 20:00:17 +00:00
|
|
|
receiveMessage(message) {
|
|
|
|
let data = message.data;
|
|
|
|
switch (message.name) {
|
|
|
|
case "gfxSanity:ContentLoaded":
|
|
|
|
this.runSanityTest();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
onWindowLoaded: function() {
|
|
|
|
let browser = this.win.document.createElementNS(XUL_NS, "browser");
|
|
|
|
browser.setAttribute("type", "content");
|
|
|
|
|
|
|
|
let remoteBrowser = Services.appinfo.browserTabsRemoteAutostart;
|
|
|
|
browser.setAttribute("remote", remoteBrowser);
|
|
|
|
|
|
|
|
browser.style.width = PAGE_WIDTH + "px";
|
|
|
|
browser.style.height = PAGE_HEIGHT + "px";
|
|
|
|
|
|
|
|
this.win.document.documentElement.appendChild(browser);
|
|
|
|
// Have to set the mm after we append the child
|
|
|
|
this.mm = browser.messageManager;
|
|
|
|
|
|
|
|
this.messages.forEach((msgName) => {
|
|
|
|
this.mm.addMessageListener(msgName, this);
|
|
|
|
});
|
|
|
|
|
|
|
|
this.mm.loadFrameScript(FRAME_SCRIPT_URL, false);
|
|
|
|
},
|
|
|
|
|
2015-06-18 20:44:04 +00:00
|
|
|
endTest: function() {
|
|
|
|
if (!this.win) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.win.ownerGlobal.close();
|
|
|
|
this.win = null;
|
|
|
|
this.utils = null;
|
|
|
|
this.canvas = null;
|
|
|
|
|
2015-07-08 20:00:17 +00:00
|
|
|
this.messages.forEach((msgName) => {
|
|
|
|
this.mm.removeMessageListener(msgName, this);
|
|
|
|
});
|
|
|
|
|
|
|
|
this.mm = null;
|
2015-06-18 20:44:04 +00:00
|
|
|
}
|
2015-06-18 20:42:35 +00:00
|
|
|
};
|
|
|
|
|
2015-06-16 22:49:26 +00:00
|
|
|
function SanityTest() {}
|
|
|
|
SanityTest.prototype = {
|
|
|
|
classID: Components.ID("{f3a8ca4d-4c83-456b-aee2-6a2cbf11e9bd}"),
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,
|
|
|
|
Ci.nsISupportsWeakReference]),
|
|
|
|
|
|
|
|
shouldRunTest: function() {
|
|
|
|
// Only test gfx features if firefox has updated, or if the user has a new
|
|
|
|
// gpu or drivers.
|
|
|
|
var appInfo = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULAppInfo);
|
|
|
|
var xulVersion = appInfo.version;
|
|
|
|
var gfxinfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
|
|
|
|
|
|
|
|
if (Preferences.get(RUNNING_PREF, false)) {
|
|
|
|
Preferences.set(DISABLE_VIDEO_PREF, true);
|
|
|
|
reportResult(TEST_CRASHED);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Handle dual GPU setups
|
2015-07-10 07:28:50 +00:00
|
|
|
if (Preferences.get(DRIVER_PREF, "") == gfxinfo.adapterDriverVersion &&
|
|
|
|
Preferences.get(DEVICE_PREF, "") == gfxinfo.adapterDeviceID &&
|
|
|
|
Preferences.get(VERSION_PREF, "") == xulVersion) {
|
2015-06-16 22:49:26 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enable hardware decoding so we can test again
|
|
|
|
// and record the driver version to detect if the driver changes.
|
|
|
|
Preferences.set(DISABLE_VIDEO_PREF, false);
|
|
|
|
Preferences.set(DRIVER_PREF, gfxinfo.adapterDriverVersion);
|
|
|
|
Preferences.set(DEVICE_PREF, gfxinfo.adapterDeviceID);
|
|
|
|
Preferences.set(VERSION_PREF, xulVersion);
|
|
|
|
|
|
|
|
// Update the prefs so that this test doesn't run again until the next update.
|
|
|
|
Preferences.set(RUNNING_PREF, true);
|
|
|
|
Services.prefs.savePrefFile(null);
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
observe: function(subject, topic, data) {
|
|
|
|
if (topic != "profile-after-change") return;
|
|
|
|
if (!this.shouldRunTest()) return;
|
|
|
|
|
|
|
|
// Open a tiny window to render our test page, and notify us when it's loaded
|
|
|
|
var sanityTest = Services.ww.openWindow(null,
|
2015-07-08 20:00:17 +00:00
|
|
|
"chrome://gfxsanity/content/sanityparent.html",
|
2015-06-16 22:49:26 +00:00
|
|
|
"Test Page",
|
|
|
|
"width=" + PAGE_WIDTH + ",height=" + PAGE_HEIGHT + ",chrome,titlebar=0,scrollbars=0",
|
|
|
|
null);
|
2015-07-02 19:47:10 +00:00
|
|
|
|
|
|
|
// There's no clean way to have an invisible window and ensure it's always painted.
|
|
|
|
// Instead, move the window far offscreen so it doesn't show up during launch.
|
|
|
|
sanityTest.moveTo(100000000,1000000000);
|
2015-06-18 20:42:35 +00:00
|
|
|
listener.scheduleTest(sanityTest);
|
2015-06-16 22:49:26 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SanityTest]);
|