nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1561435 - Format image/, a=automatic-formatting

Browse source 
# ignore-this-changeset

Differential Revision: https://phabricator.services.mozilla.com/D35906

--HG--
extra : source : a224e9d645e49dd7a343f88bd95c0da61aff0f6a
This commit is contained in:
Victor Porof 2019-07-05 10:47:38 +02:00
parent 054a393a76
commit 06e7696b74
18 changed files with 2739 additions and 1694 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

1
.eslintrc.js
View file

@ -45,7 +45,6 @@ module.exports = {
"overrides": [{
"files": [
"devtools/**",
"image/**",
"intl/**",
"ipc/**",
"js/**",

1
.prettierignore
View file

@ -40,7 +40,6 @@ toolkit/components/telemetry/datareporting-prefs.js
toolkit/components/telemetry/healthreport-prefs.js
# Ignore all top-level directories for now.
image/**
intl/**
ipc/**
js/**

69
image/test/browser/browser_bug666317.js
View file

@ -1,14 +1,16 @@
waitForExplicitFinish();
var pageSource =
'<html><body>' +
'<img id="testImg" src="' + TESTROOT + 'big.png">' +
'</body></html>';
"<html><body>" +
'<img id="testImg" src="' +
TESTROOT +
'big.png">' +
"</body></html>";
var oldDiscardingPref, oldTab, newTab;
var prefBranch = Cc["@mozilla.org/preferences-service;1"]
.getService(Ci.nsIPrefService)
.getBranch('image.mem.');
.getBranch("image.mem.");
var gWaitingForDiscard = false;
var gScriptedObserver;
@ -17,78 +19,80 @@ var gClonedRequest;
function ImageObserver(decodeCallback, discardCallback) {
this.decodeComplete = function onDecodeComplete(aRequest) {
decodeCallback();
}
};
this.discard = function onDiscard(request)
{
this.discard = function onDiscard(request) {
if (!gWaitingForDiscard) {
return;
}
this.synchronous = false;
discardCallback();
}
};
this.synchronous = true;
}
function currentRequest() {
let img = gBrowser.getBrowserForTab(newTab).contentWindow
.document.getElementById('testImg');
let img = gBrowser
.getBrowserForTab(newTab)
.contentWindow.document.getElementById("testImg");
return img.getRequest(Ci.nsIImageLoadingContent.CURRENT_REQUEST);
}
function isImgDecoded() {
let request = currentRequest();
return request.imageStatus & Ci.imgIRequest.STATUS_DECODE_COMPLETE ? true : false;
return request.imageStatus & Ci.imgIRequest.STATUS_DECODE_COMPLETE
? true
: false;
}
// Ensure that the image is decoded by drawing it to a canvas.
function forceDecodeImg() {
let doc = gBrowser.getBrowserForTab(newTab).contentWindow.document;
let img = doc.getElementById('testImg');
let canvas = doc.createElement('canvas');
let ctx = canvas.getContext('2d');
let img = doc.getElementById("testImg");
let canvas = doc.createElement("canvas");
let ctx = canvas.getContext("2d");
ctx.drawImage(img, 0, 0);
}
function runAfterAsyncEvents(aCallback) {
function handlePostMessage(aEvent) {
if (aEvent.data == 'next') {
window.removeEventListener('message', handlePostMessage);
if (aEvent.data == "next") {
window.removeEventListener("message", handlePostMessage);
aCallback();
}
}
window.addEventListener('message', handlePostMessage);
window.addEventListener("message", handlePostMessage);
// We'll receive the 'message' event after everything else that's currently in
// the event queue (which is a stronger guarantee than setTimeout, because
// setTimeout events may be coalesced). This lets us ensure that we run
// aCallback *after* any asynchronous events are delivered.
window.postMessage('next', '*');
window.postMessage("next", "*");
}
function test() {
// Enable the discarding pref.
oldDiscardingPref = prefBranch.getBoolPref('discardable');
prefBranch.setBoolPref('discardable', true);
oldDiscardingPref = prefBranch.getBoolPref("discardable");
prefBranch.setBoolPref("discardable", true);
// Create and focus a new tab.
oldTab = gBrowser.selectedTab;
newTab = BrowserTestUtils.addTab(gBrowser, 'data:text/html,' + pageSource);
newTab = BrowserTestUtils.addTab(gBrowser, "data:text/html," + pageSource);
gBrowser.selectedTab = newTab;
// Run step2 after the tab loads.
gBrowser.getBrowserForTab(newTab)
.addEventListener("pageshow", step2);
gBrowser.getBrowserForTab(newTab).addEventListener("pageshow", step2);
}
function step2() {
// Create the image observer.
var observer =
new ImageObserver(() => runAfterAsyncEvents(step3), // DECODE_COMPLETE
() => runAfterAsyncEvents(step5)); // DISCARD
var observer = new ImageObserver(
() => runAfterAsyncEvents(step3), // DECODE_COMPLETE
() => runAfterAsyncEvents(step5)
); // DISCARD
gScriptedObserver = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(observer);
@ -105,7 +109,7 @@ function step2() {
}
function step3() {
ok(isImgDecoded(), 'Image should initially be decoded.');
ok(isImgDecoded(), "Image should initially be decoded.");
// Focus the old tab, then fire a memory-pressure notification. This should
// cause the decoded image in the new tab to be discarded.
@ -118,20 +122,21 @@ function step3() {
function step4() {
gWaitingForDiscard = true;
var os = Cc["@mozilla.org/observer-service;1"]
.getService(Ci.nsIObserverService);
os.notifyObservers(null, 'memory-pressure', 'heap-minimize');
var os = Cc["@mozilla.org/observer-service;1"].getService(
Ci.nsIObserverService
);
os.notifyObservers(null, "memory-pressure", "heap-minimize");
// The DISCARD notification is delivered asynchronously. ImageObserver will
// eventually call step5. (Or else, sadly, the test will time out.)
}
function step5() {
ok(true, 'Image should be discarded.');
ok(true, "Image should be discarded.");
// And we're done.
gBrowser.removeTab(newTab);
prefBranch.setBoolPref('discardable', oldDiscardingPref);
prefBranch.setBoolPref("discardable", oldDiscardingPref);
gClonedRequest.cancelAndForgetObserver(0);

75
image/test/browser/browser_docshell_type_editor.js
View file

@ -1,4 +1,3 @@
"use strict";
const SIMPLE_HTML = "data:text/html,<html><head></head><body></body></html>";
@ -10,8 +9,7 @@ const SIMPLE_HTML = "data:text/html,<html><head></head><body></body></html>";
*/
function getManifestDir() {
let path = getTestFilePath("browser_docshell_type_editor");
let file = Cc["@mozilla.org/file/local;1"]
.createInstance(Ci.nsIFile);
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
file.initWithPath(path);
return file;
}
@ -28,22 +26,26 @@ add_task(async function() {
let manifestDir = getManifestDir();
Components.manager.addBootstrappedManifestLocation(manifestDir);
await BrowserTestUtils.withNewTab({
await BrowserTestUtils.withNewTab(
{
gBrowser,
url: SIMPLE_HTML
}, async function(browser) {
url: SIMPLE_HTML,
},
async function(browser) {
await ContentTask.spawn(browser, null, async function() {
let rootDocShell = docShell.QueryInterface(Ci.nsIDocShellTreeItem)
.rootTreeItem
.QueryInterface(Ci.nsIInterfaceRequestor)
let rootDocShell = docShell
.QueryInterface(Ci.nsIDocShellTreeItem)
.rootTreeItem.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIDocShell);
let defaultAppType = rootDocShell.appType;
rootDocShell.appType = Ci.nsIDocShell.APP_TYPE_EDITOR;
is(rootDocShell.appType, Ci.nsIDocShell.APP_TYPE_EDITOR,
"sanity check: appType after update should be type editor");
is(
rootDocShell.appType,
Ci.nsIDocShell.APP_TYPE_EDITOR,
"sanity check: appType after update should be type editor"
);
return new Promise(resolve => {
let doc = content.document;
@ -53,67 +55,82 @@ add_task(async function() {
// restore appType of rootDocShell before moving on to the next test
rootDocShell.appType = defaultAppType;
resolve();
}
};
image.onerror = function() {
ok(false, "APP_TYPE_EDITOR is allowed to load privileged image");
// restore appType of rootDocShell before moving on to the next test
rootDocShell.appType = defaultAppType;
resolve();
}
};
doc.body.appendChild(image);
image.src = "chrome://test1/skin/privileged.png";
});
});
});
}
);
Components.manager.removeBootstrappedManifestLocation(manifestDir);
});
add_task(async function() {
info("docshell of appType APP_TYPE_UNKNOWN can *not* access privileged images.");
info(
"docshell of appType APP_TYPE_UNKNOWN can *not* access privileged images."
);
// Load a temporary manifest adding a route to a privileged image
let manifestDir = getManifestDir();
Components.manager.addBootstrappedManifestLocation(manifestDir);
await BrowserTestUtils.withNewTab({
await BrowserTestUtils.withNewTab(
{
gBrowser,
url: SIMPLE_HTML
}, async function(browser) {
url: SIMPLE_HTML,
},
async function(browser) {
await ContentTask.spawn(browser, null, async function() {
let rootDocShell = docShell.QueryInterface(Ci.nsIDocShellTreeItem)
.rootTreeItem
.QueryInterface(Ci.nsIInterfaceRequestor)
let rootDocShell = docShell
.QueryInterface(Ci.nsIDocShellTreeItem)
.rootTreeItem.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIDocShell);
let defaultAppType = rootDocShell.appType;
rootDocShell.appType = Ci.nsIDocShell.APP_TYPE_UNKNOWN;
is(rootDocShell.appType, Ci.nsIDocShell.APP_TYPE_UNKNOWN,
"sanity check: appType of docshell should be unknown");
is(
rootDocShell.appType,
Ci.nsIDocShell.APP_TYPE_UNKNOWN,
"sanity check: appType of docshell should be unknown"
);
return new Promise(resolve => {
let doc = content.document;
let image = doc.createElement("img");
image.onload = function() {
ok(false, "APP_TYPE_UNKNOWN is *not* allowed to acces privileged image");
ok(
false,
"APP_TYPE_UNKNOWN is *not* allowed to acces privileged image"
);
// restore appType of rootDocShell before moving on to the next test
rootDocShell.appType = defaultAppType;
resolve();
}
};
image.onerror = function() {
ok(true, "APP_TYPE_UNKNOWN is *not* allowed to acces privileged image");
ok(
true,
"APP_TYPE_UNKNOWN is *not* allowed to acces privileged image"
);
// restore appType of rootDocShell before moving on to the next test
rootDocShell.appType = defaultAppType;
resolve();
}
};
doc.body.appendChild(image);
// Set the src via wrappedJSObject so the load is triggered with
// the content page's principal rather than ours.
image.wrappedJSObject.src = "chrome://test1/skin/privileged.png";
});
});
});
}
);
Components.manager.removeBootstrappedManifestLocation(manifestDir);
});

132
image/test/browser/browser_image.js
View file

@ -11,20 +11,29 @@ function testBFCache() {
function theTest() {
var abort = false;
var chances, gImage, gFrames;
gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, TESTROOT + "image.html");
gBrowser.selectedBrowser.addEventListener("pageshow", function () {
gBrowser.selectedTab = BrowserTestUtils.addTab(
gBrowser,
TESTROOT + "image.html"
);
gBrowser.selectedBrowser.addEventListener(
"pageshow",
function() {
var window = gBrowser.contentWindow;
// If false, we are in an optimized build, and we abort this and
// all further tests
if (!actOnMozImage(window.document, "img1", function(image) {
if (
!actOnMozImage(window.document, "img1", function(image) {
gImage = image;
gFrames = gImage.framesNotified;
})) {
})
) {
gBrowser.removeCurrentTab();
abort = true;
}
goer.next();
}, {capture: true, once: true});
},
{ capture: true, once: true }
);
yield;
if (abort) {
finish();
@ -35,15 +44,19 @@ function testBFCache() {
chances = 120;
do {
gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
gTimer.initWithCallback(function() {
gTimer.initWithCallback(
function() {
if (gImage.framesNotified >= 20) {
goer.send(true);
} else {
chances--;
goer.send(chances == 0); // maybe if we wait a bit, it will happen
}
}, 500, Ci.nsITimer.TYPE_ONE_SHOT);
} while (!(yield));
},
500,
Ci.nsITimer.TYPE_ONE_SHOT
);
} while (!yield);
is(chances > 0, true, "Must have animated a few frames so far");
// Browse elsewhere; push our animating page into the bfcache
@ -52,16 +65,30 @@ function testBFCache() {
// Wait a bit for page to fully load, then wait a while and
// see that no animation occurs.
gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
gTimer.initWithCallback(function() {
gTimer.initWithCallback(
function() {
gFrames = gImage.framesNotified;
gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
gTimer.initWithCallback(function() {
gTimer.initWithCallback(
function() {
// Might have a few stray frames, until other page totally loads
var additionalFrames = gImage.framesNotified - gFrames;
is(additionalFrames == 0, true, "Must have not animated in bfcache! Got " + additionalFrames + " additional frames");
is(
additionalFrames == 0,
true,
"Must have not animated in bfcache! Got " +
additionalFrames +
" additional frames"
);
goer.next();
}, 4000, Ci.nsITimer.TYPE_ONE_SHOT); // 4 seconds - expect 40 frames
}, 0, Ci.nsITimer.TYPE_ONE_SHOT); // delay of 0 - wait for next event loop
},
4000,
Ci.nsITimer.TYPE_ONE_SHOT
); // 4 seconds - expect 40 frames
},
0,
Ci.nsITimer.TYPE_ONE_SHOT
); // delay of 0 - wait for next event loop
yield;
// Go back
@ -70,15 +97,19 @@ function testBFCache() {
chances = 120;
do {
gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
gTimer.initWithCallback(function() {
gTimer.initWithCallback(
function() {
if (gImage.framesNotified - gFrames >= 20) {
goer.send(true);
} else {
chances--;
goer.send(chances == 0); // maybe if we wait a bit, it will happen
}
}, 500, Ci.nsITimer.TYPE_ONE_SHOT);
} while (!(yield));
},
500,
Ci.nsITimer.TYPE_ONE_SHOT
);
} while (!yield);
is(chances > 0, true, "Must have animated once out of bfcache!");
// Finally, check that the css background image has essentially the same
@ -90,9 +121,17 @@ function testBFCache() {
var div = doc.getElementById("background_div");
div.innerHTML += '<img src="animated2.gif" id="img3">';
actOnMozImage(doc, "img3", function(image) {
is(Math.abs(image.framesNotified - gImage.framesNotified)/gImage.framesNotified < 0.5, true,
is(
Math.abs(image.framesNotified - gImage.framesNotified) /
gImage.framesNotified <
0.5,
true,
"Must have also animated the background image, and essentially the same # of frames. " +
"Regular image got " + gImage.framesNotified + " frames but background image got " + image.framesNotified);
"Regular image got " +
gImage.framesNotified +
" frames but background image got " +
image.framesNotified
);
});
gBrowser.removeCurrentTab();
@ -111,48 +150,74 @@ function testSharedContainers() {
var gImages = [];
var gFrames;
gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, TESTROOT + "image.html");
gBrowser.selectedBrowser.addEventListener("pageshow", function () {
gBrowser.selectedTab = BrowserTestUtils.addTab(
gBrowser,
TESTROOT + "image.html"
);
gBrowser.selectedBrowser.addEventListener(
"pageshow",
function() {
actOnMozImage(gBrowser.contentDocument, "img1", function(image) {
gImages[0] = image;
gFrames = image.framesNotified; // May in theory have frames from last test
// in this counter - so subtract them out
});
goer.next();
}, {capture: true, once: true});
},
{ capture: true, once: true }
);
yield;
// Load next tab somewhat later
gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
gTimer.initWithCallback(function() {
gTimer.initWithCallback(
function() {
goer.next();
}, 1500, Ci.nsITimer.TYPE_ONE_SHOT);
},
1500,
Ci.nsITimer.TYPE_ONE_SHOT
);
yield;
gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, TESTROOT + "imageX2.html");
gBrowser.selectedBrowser.addEventListener("pageshow", function () {
gBrowser.selectedTab = BrowserTestUtils.addTab(
gBrowser,
TESTROOT + "imageX2.html"
);
gBrowser.selectedBrowser.addEventListener(
"pageshow",
function() {
[1, 2].forEach(function(i) {
actOnMozImage(gBrowser.contentDocument, "img" + i, function(image) {
gImages[i] = image;
});
});
goer.next();
}, {capture: true, once: true});
},
{ capture: true, once: true }
);
yield;
var chances = 120;
do {
gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
gTimer.initWithCallback(function() {
gTimer.initWithCallback(
function() {
if (gImages[0].framesNotified - gFrames >= 10) {
goer.send(true);
} else {
chances--;
goer.send(chances == 0); // maybe if we wait a bit, it will happen
}
}, 500, Ci.nsITimer.TYPE_ONE_SHOT);
} while (!(yield));
is(chances > 0, true, "Must have been animating while showing several images");
},
500,
Ci.nsITimer.TYPE_ONE_SHOT
);
} while (!yield);
is(
chances > 0,
true,
"Must have been animating while showing several images"
);
// Check they all have the same frame counts
var theFrames = null;
@ -161,7 +226,11 @@ function testSharedContainers() {
if (theFrames == null) {
theFrames = frames;
} else {
is(theFrames, frames, "Sharing the same imgContainer means *exactly* the same frame counts!");
is(
theFrames,
frames,
"Sharing the same imgContainer means *exactly* the same frame counts!"
);
}
});
@ -189,4 +258,3 @@ function test() {
ignoreAllUncaughtExceptions();
nextTest();
}

7
image/test/browser/head.js
View file

@ -12,12 +12,13 @@ function getImageLoading(doc, id) {
// Tries to get the Moz debug image, imgIContainerDebug. Only works
// in a debug build. If we succeed, we call func().
function actOnMozImage(doc, id, func) {
var imgContainer = getImageLoading(doc, id).getRequest(Ci.nsIImageLoadingContent.CURRENT_REQUEST).image;
var imgContainer = getImageLoading(doc, id).getRequest(
Ci.nsIImageLoadingContent.CURRENT_REQUEST
).image;
var mozImage;
try {
mozImage = imgContainer.QueryInterface(Ci.imgIContainerDebug);
}
catch (e) {
} catch (e) {
return false;
}
func(mozImage);

214
image/test/mochitest/animationPolling.js
View file

@ -3,49 +3,56 @@ var currentTest;
var gIsRefImageLoaded = false;
const gShouldOutputDebugInfo = false;
function pollForSuccess()
{
function pollForSuccess() {
if (!currentTest.isTestFinished) {
if (!currentTest.reusingReferenceImage || (currentTest.reusingReferenceImage
&& gRefImageLoaded)) {
if (
!currentTest.reusingReferenceImage ||
(currentTest.reusingReferenceImage && gRefImageLoaded)
) {
currentTest.checkImage();
}
setTimeout(pollForSuccess, currentTest.pollFreq);
}
};
}
function referencePoller()
{
function referencePoller() {
currentTest.takeReferenceSnapshot();
}
function reuseImageCallback()
{
function reuseImageCallback() {
gIsRefImageLoaded = true;
}
function failTest()
{
function failTest() {
if (currentTest.isTestFinished || currentTest.closeFunc) {
return;
}
ok(false, "timing out after " + currentTest.timeout + "ms. "
+ "Animated image still doesn't look correct, after poll #"
+ currentTest.pollCounter);
ok(
false,
"timing out after " +
currentTest.timeout +
"ms. " +
"Animated image still doesn't look correct, after poll #" +
currentTest.pollCounter
);
currentTest.wereFailures = true;
if (currentTest.currentSnapshotDataURI) {
currentTest.outputDebugInfo("Snapshot #" + currentTest.pollCounter,
currentTest.outputDebugInfo(
"Snapshot #" + currentTest.pollCounter,
"snapNum" + currentTest.pollCounter,
currentTest.currentSnapshotDataURI);
currentTest.currentSnapshotDataURI
);
}
currentTest.enableDisplay(document.getElementById(currentTest.debugElementId));
currentTest.enableDisplay(
document.getElementById(currentTest.debugElementId)
);
currentTest.cleanUpAndFinish();
};
}
/**
* Create a new AnimationTest object.
@ -75,9 +82,17 @@ function failTest()
* chain tests together, so they are all finished exactly once.
* @returns {AnimationTest}
*/
function AnimationTest(pollFreq, timeout, referenceElementId, imageElementId,
debugElementId, cleanId, srcAttr, xulTest, closeFunc)
{
function AnimationTest(
pollFreq,
timeout,
referenceElementId,
imageElementId,
debugElementId,
cleanId,
srcAttr,
xulTest,
closeFunc
) {
// We want to test the cold loading behavior, so clear cache in case an
// earlier test got our image in there already.
clearAllImageCaches();
@ -103,24 +118,24 @@ function AnimationTest(pollFreq, timeout, referenceElementId, imageElementId,
this.numRefsTaken = 0;
this.blankWaitTime = 0;
this.cleanId = cleanId ? cleanId : '';
this.xulTest = xulTest ? xulTest : '';
this.closeFunc = closeFunc ? closeFunc : '';
};
this.cleanId = cleanId ? cleanId : "";
this.xulTest = xulTest ? xulTest : "";
this.closeFunc = closeFunc ? closeFunc : "";
}
AnimationTest.prototype.preloadImage = function()
{
AnimationTest.prototype.preloadImage = function() {
if (this.srcAttr) {
this.myImage = new Image();
this.myImage.onload = function() { currentTest.continueTest(); };
this.myImage.onload = function() {
currentTest.continueTest();
};
this.myImage.src = this.srcAttr;
} else {
this.continueTest();
}
};
AnimationTest.prototype.outputDebugInfo = function(message, id, dataUri)
{
AnimationTest.prototype.outputDebugInfo = function(message, id, dataUri) {
if (!gShouldOutputDebugInfo) {
return;
}
@ -135,13 +150,11 @@ AnimationTest.prototype.outputDebugInfo = function(message, id, dataUri)
todo(false, "Debug (" + id + "): " + message + " " + dataUri);
};
AnimationTest.prototype.isFinished = function()
{
AnimationTest.prototype.isFinished = function() {
return this.isTestFinished;
};
AnimationTest.prototype.takeCleanSnapshot = function()
{
AnimationTest.prototype.takeCleanSnapshot = function() {
var cleanElement;
if (this.cleanId) {
cleanElement = document.getElementById(this.cleanId);
@ -161,18 +174,23 @@ AnimationTest.prototype.takeCleanSnapshot = function()
}
var dataString1 = "Clean Snapshot";
this.outputDebugInfo(dataString1, 'cleanSnap',
this.cleanSnapshot.toDataURL());
this.outputDebugInfo(
dataString1,
"cleanSnap",
this.cleanSnapshot.toDataURL()
);
};
AnimationTest.prototype.takeBlankSnapshot = function()
{
AnimationTest.prototype.takeBlankSnapshot = function() {
// Take a snapshot of the initial (essentially blank) page
this.blankSnapshot = snapshotWindow(window, false);
var dataString1 = "Initial Blank Snapshot";
this.outputDebugInfo(dataString1, 'blank1Snap',
this.blankSnapshot.toDataURL());
this.outputDebugInfo(
dataString1,
"blank1Snap",
this.blankSnapshot.toDataURL()
);
};
/**
@ -182,8 +200,7 @@ AnimationTest.prototype.takeBlankSnapshot = function()
* image, if applicable, and then asynchronously call continueTest(), or if not
* applicable, synchronously trigger a call to continueTest().
*/
AnimationTest.prototype.beginTest = function()
{
AnimationTest.prototype.beginTest = function() {
SimpleTest.waitForExplicitFinish();
SimpleTest.requestFlakyTimeout("untriaged");
@ -196,8 +213,7 @@ AnimationTest.prototype.beginTest = function()
* beginTest() either synchronously or asynchronously, as an image load
* callback.
*/
AnimationTest.prototype.continueTest = function()
{
AnimationTest.prototype.continueTest = function() {
// In case something goes wrong, fail earlier than mochitest timeout,
// and with more information.
setTimeout(failTest, this.timeout);
@ -211,34 +227,35 @@ AnimationTest.prototype.continueTest = function()
SimpleTest.executeSoon(pollForSuccess);
};
AnimationTest.prototype.setupPolledImage = function ()
{
AnimationTest.prototype.setupPolledImage = function() {
// Make sure the image is visible
if (!this.reusingImageAsReference) {
this.enableDisplay(document.getElementById(this.imageElementId));
var currentSnapshot = snapshotWindow(window, false);
var result = compareSnapshots(currentSnapshot,
this.referenceSnapshot, true);
var result = compareSnapshots(
currentSnapshot,
this.referenceSnapshot,
true
);
this.currentSnapshotDataURI = currentSnapshot.toDataURL();
if (result[0]) {
// SUCCESS!
ok(true, "Animated image looks correct, at poll #"
+ this.pollCounter);
ok(true, "Animated image looks correct, at poll #" + this.pollCounter);
this.cleanUpAndFinish();
}
} else if (!gIsRefImageLoaded) {
this.myImage = new Image();
this.myImage.onload = reuseImageCallback;
document.getElementById(this.imageElementId).setAttribute('src',
this.referenceElementId);
}
document
.getElementById(this.imageElementId)
.setAttribute("src", this.referenceElementId);
}
};
AnimationTest.prototype.checkImage = function ()
{
AnimationTest.prototype.checkImage = function() {
if (this.isTestFinished) {
return;
}
@ -258,15 +275,13 @@ AnimationTest.prototype.checkImage = function ()
if (result[0]) {
// SUCCESS!
ok(true, "Animated image looks correct, at poll #"
+ this.pollCounter);
ok(true, "Animated image looks correct, at poll #" + this.pollCounter);
this.cleanUpAndFinish();
}
};
AnimationTest.prototype.takeReferenceSnapshot = function ()
{
AnimationTest.prototype.takeReferenceSnapshot = function() {
this.numRefsTaken++;
// Test to make sure the reference image doesn't match a clean snapshot
@ -286,15 +301,20 @@ AnimationTest.prototype.takeReferenceSnapshot = function ()
this.referenceSnapshot = snapshotWindow(window, false);
var snapResult = compareSnapshots(this.cleanSnapshot,
this.referenceSnapshot, false);
var snapResult = compareSnapshots(
this.cleanSnapshot,
this.referenceSnapshot,
false
);
if (!snapResult[0]) {
if (this.blankWaitTime > 2000) {
// if it took longer than two seconds to load the image, we probably
// have a problem.
this.wereFailures = true;
ok(snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot");
ok(
snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot"
);
} else {
this.blankWaitTime += currentTest.pollFreq;
// let's wait a bit and see if it clears up
@ -303,12 +323,17 @@ AnimationTest.prototype.takeReferenceSnapshot = function ()
}
}
ok(snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot");
ok(
snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot"
);
var dataString = "Reference Snapshot #" + this.numRefsTaken;
this.outputDebugInfo(dataString, 'refSnapId',
this.referenceSnapshot.toDataURL());
this.outputDebugInfo(
dataString,
"refSnapId",
this.referenceSnapshot.toDataURL()
);
} else {
// Make sure the animation section is hidden
this.disableDisplay(document.getElementById(this.imageElementId));
@ -318,15 +343,20 @@ AnimationTest.prototype.takeReferenceSnapshot = function ()
this.enableDisplay(referenceDiv);
this.referenceSnapshot = snapshotWindow(window, false);
var snapResult = compareSnapshots(this.cleanSnapshot,
this.referenceSnapshot, false);
var snapResult = compareSnapshots(
this.cleanSnapshot,
this.referenceSnapshot,
false
);
if (!snapResult[0]) {
if (this.blankWaitTime > 2000) {
// if it took longer than two seconds to load the image, we probably
// have a problem.
this.wereFailures = true;
ok(snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot");
ok(
snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot"
);
} else {
this.blankWaitTime += 20;
// let's wait a bit and see if it clears up
@ -335,12 +365,17 @@ AnimationTest.prototype.takeReferenceSnapshot = function ()
}
}
ok(snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot");
ok(
snapResult[0],
"Reference snapshot shouldn't match clean (non-image) snapshot"
);
var dataString = "Reference Snapshot #" + this.numRefsTaken;
this.outputDebugInfo(dataString, 'refSnapId',
this.referenceSnapshot.toDataURL());
this.outputDebugInfo(
dataString,
"refSnapId",
this.referenceSnapshot.toDataURL()
);
// Re-hide reference div, and take another snapshot to be sure it's gone
this.disableDisplay(referenceDiv);
@ -348,47 +383,46 @@ AnimationTest.prototype.takeReferenceSnapshot = function ()
}
};
AnimationTest.prototype.enableDisplay = function(element)
{
AnimationTest.prototype.enableDisplay = function(element) {
if (!element) {
return;
}
if (!this.xulTest) {
element.style.display = '';
element.style.display = "";
} else {
element.setAttribute('hidden', 'false');
element.setAttribute("hidden", "false");
}
};
AnimationTest.prototype.disableDisplay = function(element)
{
AnimationTest.prototype.disableDisplay = function(element) {
if (!element) {
return;
}
if (!this.xulTest) {
element.style.display = 'none';
element.style.display = "none";
} else {
element.setAttribute('hidden', 'true');
element.setAttribute("hidden", "true");
}
};
AnimationTest.prototype.testBlankCameBack = function()
{
AnimationTest.prototype.testBlankCameBack = function() {
var blankSnapshot2 = snapshotWindow(window, false);
var result = compareSnapshots(this.blankSnapshot, blankSnapshot2, true);
ok(result[0], "Reference image should disappear when it becomes display:none");
ok(
result[0],
"Reference image should disappear when it becomes display:none"
);
if (!result[0]) {
this.wereFailures = true;
var dataString = "Second Blank Snapshot";
this.outputDebugInfo(dataString, 'blank2SnapId', result[2]);
this.outputDebugInfo(dataString, "blank2SnapId", result[2]);
}
};
AnimationTest.prototype.cleanUpAndFinish = function ()
{
AnimationTest.prototype.cleanUpAndFinish = function() {
// On the off chance that failTest and checkImage are triggered
// back-to-back, use a flag to prevent multiple calls to SimpleTest.finish.
if (this.isTestFinished) {
@ -404,7 +438,7 @@ AnimationTest.prototype.cleanUpAndFinish = function ()
}
if (this.wereFailures) {
document.getElementById(this.debugElementId).style.display = 'block';
document.getElementById(this.debugElementId).style.display = "block";
}
SimpleTest.finish();

108
image/test/mochitest/imgutils.js
View file

@ -5,50 +5,47 @@
// check mxr before removing or changing functionality.
// Helper function to clear both the content and chrome image caches
function clearAllImageCaches()
{
var tools = SpecialPowers.Cc["@mozilla.org/image/tools;1"]
.getService(SpecialPowers.Ci.imgITools);
function clearAllImageCaches() {
var tools = SpecialPowers.Cc["@mozilla.org/image/tools;1"].getService(
SpecialPowers.Ci.imgITools
);
var imageCache = tools.getImgCacheForDocument(window.document);
imageCache.clearCache(true); // true=chrome
imageCache.clearCache(false); // false=content
}
// Helper function to clear the image cache of content images
function clearImageCache()
{
var tools = SpecialPowers.Cc["@mozilla.org/image/tools;1"]
.getService(SpecialPowers.Ci.imgITools);
function clearImageCache() {
var tools = SpecialPowers.Cc["@mozilla.org/image/tools;1"].getService(
SpecialPowers.Ci.imgITools
);
var imageCache = tools.getImgCacheForDocument(window.document);
imageCache.clearCache(false); // true=chrome, false=content
}
// Helper function to determine if the frame is decoded for a given image id
function isFrameDecoded(id)
{
return (getImageStatus(id) &
SpecialPowers.Ci.imgIRequest.STATUS_FRAME_COMPLETE)
? true : false;
function isFrameDecoded(id) {
return getImageStatus(id) & SpecialPowers.Ci.imgIRequest.STATUS_FRAME_COMPLETE
? true
: false;
}
// Helper function to determine if the image is loaded for a given image id
function isImageLoaded(id)
{
return (getImageStatus(id) &
SpecialPowers.Ci.imgIRequest.STATUS_LOAD_COMPLETE)
? true : false;
function isImageLoaded(id) {
return getImageStatus(id) & SpecialPowers.Ci.imgIRequest.STATUS_LOAD_COMPLETE
? true
: false;
}
// Helper function to get the status flags of an image
function getImageStatus(id)
{
function getImageStatus(id) {
// Get the image
var img = SpecialPowers.wrap(document.getElementById(id));
// Get the request
var request = img.getRequest(SpecialPowers.Ci
.nsIImageLoadingContent
.CURRENT_REQUEST);
var request = img.getRequest(
SpecialPowers.Ci.nsIImageLoadingContent.CURRENT_REQUEST
);
// Return the status
return request.imageStatus;
@ -56,8 +53,7 @@ function getImageStatus(id)
// Forces a synchronous decode of an image by drawing it to a canvas. Only
// really meaningful if the image is fully loaded first
function forceDecode(id)
{
function forceDecode(id) {
// Get the image
var img = document.getElementById(id);
@ -69,7 +65,6 @@ function forceDecode(id)
ctx.drawImage(img, 0, 0);
}
// Functions to facilitate getting/setting various image-related prefs
//
// If you change a pref in a mochitest, Don't forget to reset it to its
@ -77,14 +72,26 @@ function forceDecode(id)
//
// Null indicates no pref set
const DISCARD_ENABLED_PREF = {name: "discardable", branch: "image.mem.", type: "bool"};
const DECODEONDRAW_ENABLED_PREF = {name: "decodeondraw", branch: "image.mem.", type: "bool"};
const DISCARD_TIMEOUT_PREF = {name: "min_discard_timeout_ms", branch: "image.mem.", type: "int"};
const DISCARD_ENABLED_PREF = {
name: "discardable",
branch: "image.mem.",
type: "bool",
};
const DECODEONDRAW_ENABLED_PREF = {
name: "decodeondraw",
branch: "image.mem.",
type: "bool",
};
const DISCARD_TIMEOUT_PREF = {
name: "min_discard_timeout_ms",
branch: "image.mem.",
type: "int",
};
function setImagePref(pref, val)
{
var prefService = SpecialPowers.Cc["@mozilla.org/preferences-service;1"]
.getService(SpecialPowers.Ci.nsIPrefService);
function setImagePref(pref, val) {
var prefService = SpecialPowers.Cc[
"@mozilla.org/preferences-service;1"
].getService(SpecialPowers.Ci.nsIPrefService);
var branch = prefService.getBranch(pref.branch);
if (val != null) {
switch (pref.type) {
@ -97,15 +104,15 @@ function setImagePref(pref, val)
default:
throw new Error("Unknown pref type");
}
}
else if (branch.prefHasUserValue(pref.name))
} else if (branch.prefHasUserValue(pref.name)) {
branch.clearUserPref(pref.name);
}
}
function getImagePref(pref)
{
var prefService = SpecialPowers.Cc["@mozilla.org/preferences-service;1"]
.getService(SpecialPowers.Ci.nsIPrefService);
function getImagePref(pref) {
var prefService = SpecialPowers.Cc[
"@mozilla.org/preferences-service;1"
].getService(SpecialPowers.Ci.nsIPrefService);
var branch = prefService.getBranch(pref.branch);
if (branch.prefHasUserValue(pref.name)) {
switch (pref.type) {
@ -116,20 +123,19 @@ function getImagePref(pref)
default:
throw new Error("Unknown pref type");
}
}
else
} else {
return null;
}
}
// JS implementation of imgIScriptedNotificationObserver with stubs for all of its methods.
function ImageDecoderObserverStub()
{
this.sizeAvailable = function sizeAvailable(aRequest) {}
this.frameComplete = function frameComplete(aRequest) {}
this.decodeComplete = function decodeComplete(aRequest) {}
this.loadComplete = function loadComplete(aRequest) {}
this.frameUpdate = function frameUpdate(aRequest) {}
this.discard = function discard(aRequest) {}
this.isAnimated = function isAnimated(aRequest) {}
this.hasTransparency = function hasTransparency(aRequest) {}
function ImageDecoderObserverStub() {
this.sizeAvailable = function sizeAvailable(aRequest) {};
this.frameComplete = function frameComplete(aRequest) {};
this.decodeComplete = function decodeComplete(aRequest) {};
this.loadComplete = function loadComplete(aRequest) {};
this.frameUpdate = function frameUpdate(aRequest) {};
this.discard = function discard(aRequest) {};
this.isAnimated = function isAnimated(aRequest) {};
this.hasTransparency = function hasTransparency(aRequest) {};
}

174
image/test/unit/async_load_tests.js
View file

@ -10,19 +10,17 @@ const {HttpServer} = ChromeUtils.import("resource://testing-common/httpd.js");
const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
var server = new HttpServer();
server.registerDirectory("/", do_get_file(''));
server.registerDirectory("/", do_get_file(""));
server.registerContentType("sjs", "sjs");
server.start(-1);
load('image_load_helpers.js');
load("image_load_helpers.js");
var requests = [];
// Return a closure that holds on to the listener from the original
// imgIRequest, and compares its results to the cloned one.
function getCloneStopCallback(original_listener)
{
function getCloneStopCallback(original_listener) {
return function cloneStop(listener) {
Assert.equal(original_listener.state, listener.state);
@ -30,35 +28,38 @@ function getCloneStopCallback(original_listener)
// twice.
Assert.notEqual(original_listener, listener);
do_test_finished();
}
};
}
// Make sure that cloned requests get all the same callbacks as the original,
// but they aren't synchronous right now.
function checkClone(other_listener, aRequest)
{
function checkClone(other_listener, aRequest) {
do_test_pending();
// For as long as clone notification is synchronous, we can't test the clone state reliably.
var listener = new ImageListener(null, function(foo, bar) { do_test_finished(); } /* getCloneStopCallback(other_listener)*/);
var listener = new ImageListener(
null,
function(foo, bar) {
do_test_finished();
} /* getCloneStopCallback(other_listener)*/
);
listener.synchronous = false;
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
var clone = aRequest.clone(outer);
requests.push({ request: clone, locked: false });
}
// Ensure that all the callbacks were called on aRequest.
function checkSizeAndLoad(listener, aRequest)
{
function checkSizeAndLoad(listener, aRequest) {
Assert.notEqual(listener.state & SIZE_AVAILABLE, 0);
Assert.notEqual(listener.state & LOAD_COMPLETE, 0);
do_test_finished();
}
function secondLoadDone(oldlistener, aRequest)
{
function secondLoadDone(oldlistener, aRequest) {
do_test_pending();
try {
@ -68,7 +69,8 @@ function secondLoadDone(oldlistener, aRequest)
// clone state reliably.
var listener = new ImageListener(null, checkSizeAndLoad);
listener.synchronous = false;
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
var staticrequestclone = staticrequest.clone(outer);
requests.push({ request: staticrequestclone, locked: false });
@ -85,22 +87,32 @@ function secondLoadDone(oldlistener, aRequest)
// Load the request a second time. This should come from the image cache, and
// therefore would be at most risk of being served synchronously.
function checkSecondLoad()
{
function checkSecondLoad() {
do_test_pending();
var listener = new ImageListener(checkClone, secondLoadDone);
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
requests.push({
request: gCurrentLoader.loadImageXPCOM(uri, null, null, "default", null, null, outer, null, 0, null),
request: gCurrentLoader.loadImageXPCOM(
uri,
null,
null,
"default",
null,
null,
outer,
null,
0,
null
),
locked: false,
});
listener.synchronous = false;
}
function firstLoadDone(oldlistener, aRequest)
{
function firstLoadDone(oldlistener, aRequest) {
checkSecondLoad(uri);
do_test_finished();
@ -108,33 +120,37 @@ function firstLoadDone(oldlistener, aRequest)
// Return a closure that allows us to check the stream listener's status when the
// image finishes loading.
function getChannelLoadImageStopCallback(streamlistener, next)
{
function getChannelLoadImageStopCallback(streamlistener, next) {
return function channelLoadStop(imglistener, aRequest) {
next();
do_test_finished();
}
};
}
// Load the request a second time. This should come from the image cache, and
// therefore would be at most risk of being served synchronously.
function checkSecondChannelLoad()
{
function checkSecondChannelLoad() {
do_test_pending();
var channel = NetUtil.newChannel({ uri, loadUsingSystemPrincipal: true });
var channellistener = new ChannelListener();
channel.asyncOpen(channellistener);
var listener = new ImageListener(null,
getChannelLoadImageStopCallback(channellistener,
all_done_callback));
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var listener = new ImageListener(
null,
getChannelLoadImageStopCallback(channellistener, all_done_callback)
);
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
var outlistener = {};
requests.push({
request: gCurrentLoader.loadImageWithChannelXPCOM(channel, outer, null, outlistener),
request: gCurrentLoader.loadImageWithChannelXPCOM(
channel,
outer,
null,
outlistener
),
locked: false,
});
channellistener.outputListener = outlistener.value;
@ -142,24 +158,32 @@ function checkSecondChannelLoad()
listener.synchronous = false;
}
function run_loadImageWithChannel_tests()
{
function run_loadImageWithChannel_tests() {
// To ensure we're testing what we expect to, create a new loader and cache.
gCurrentLoader = Cc["@mozilla.org/image/loader;1"].createInstance(Ci.imgILoader);
gCurrentLoader = Cc["@mozilla.org/image/loader;1"].createInstance(
Ci.imgILoader
);
do_test_pending();
var channel = NetUtil.newChannel({ uri, loadUsingSystemPrincipal: true });
var channellistener = new ChannelListener();
channel.asyncOpen(channellistener);
var listener = new ImageListener(null,
getChannelLoadImageStopCallback(channellistener,
checkSecondChannelLoad));
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var listener = new ImageListener(
null,
getChannelLoadImageStopCallback(channellistener, checkSecondChannelLoad)
);
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
var outlistener = {};
requests.push({
request: gCurrentLoader.loadImageWithChannelXPCOM(channel, outer, null, outlistener),
request: gCurrentLoader.loadImageWithChannelXPCOM(
channel,
outer,
null,
outlistener
),
locked: false,
});
channellistener.outputListener = outlistener.value;
@ -167,54 +191,84 @@ function run_loadImageWithChannel_tests()
listener.synchronous = false;
}
function all_done_callback()
{
server.stop(function() { do_test_finished(); });
function all_done_callback() {
server.stop(function() {
do_test_finished();
});
}
function startImageCallback(otherCb)
{
return function(listener, request)
{
function startImageCallback(otherCb) {
return function(listener, request) {
// Make sure we can load the same image immediately out of the cache.
do_test_pending();
var listener2 = new ImageListener(null, function(foo, bar) { do_test_finished(); });
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var listener2 = new ImageListener(null, function(foo, bar) {
do_test_finished();
});
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener2);
requests.push({
request: gCurrentLoader.loadImageXPCOM(uri, null, null, "default", null, null, outer, null, 0, null),
request: gCurrentLoader.loadImageXPCOM(
uri,
null,
null,
"default",
null,
null,
outer,
null,
0,
null
),
locked: false,
});
listener2.synchronous = false;
// Now that we've started another load, chain to the callback.
otherCb(listener, request);
}
};
}
var gCurrentLoader;
function cleanup()
{
function cleanup() {
for (let { request, locked } of requests) {
if (locked) {
try { request.unlockImage() } catch (e) {}
try {
request.unlockImage();
} catch (e) {}
}
request.cancelAndForgetObserver(0);
}
}
function run_test()
{
function run_test() {
registerCleanupFunction(cleanup);
gCurrentLoader = Cc["@mozilla.org/image/loader;1"].createInstance(Ci.imgILoader);
gCurrentLoader = Cc["@mozilla.org/image/loader;1"].createInstance(
Ci.imgILoader
);
do_test_pending();
var listener = new ImageListener(startImageCallback(checkClone), firstLoadDone);
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var listener = new ImageListener(
startImageCallback(checkClone),
firstLoadDone
);
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
var req = gCurrentLoader.loadImageXPCOM(uri, null, null, "default", null, null, outer, null, 0, null);
var req = gCurrentLoader.loadImageXPCOM(
uri,
null,
null,
"default",
null,
null,
outer,
null,
0,
null
);
// Ensure that we don't cause any mayhem when we lock an image.
req.lockImage();

78
image/test/unit/image_load_helpers.js
View file

@ -21,44 +21,37 @@ do_get_profile();
// An implementation of imgIScriptedNotificationObserver with the ability to
// call specified functions on onStartRequest and onStopRequest.
function ImageListener(start_callback, stop_callback)
{
this.sizeAvailable = function onSizeAvailable(aRequest)
{
function ImageListener(start_callback, stop_callback) {
this.sizeAvailable = function onSizeAvailable(aRequest) {
Assert.ok(!this.synchronous);
this.state |= SIZE_AVAILABLE;
if (this.start_callback)
if (this.start_callback) {
this.start_callback(this, aRequest);
}
this.frameComplete = function onFrameComplete(aRequest)
{
};
this.frameComplete = function onFrameComplete(aRequest) {
Assert.ok(!this.synchronous);
this.state |= FRAME_COMPLETE;
}
this.decodeComplete = function onDecodeComplete(aRequest)
{
};
this.decodeComplete = function onDecodeComplete(aRequest) {
Assert.ok(!this.synchronous);
this.state |= DECODE_COMPLETE;
}
this.loadComplete = function onLoadcomplete(aRequest)
{
};
this.loadComplete = function onLoadcomplete(aRequest) {
Assert.ok(!this.synchronous);
this.state |= LOAD_COMPLETE;
if (this.stop_callback)
if (this.stop_callback) {
this.stop_callback(this, aRequest);
}
this.frameUpdate = function onFrameUpdate(aRequest)
{
}
this.isAnimated = function onIsAnimated()
{
}
};
this.frameUpdate = function onFrameUpdate(aRequest) {};
this.isAnimated = function onIsAnimated() {};
// Initialize the synchronous flag to true to start. This must be set to
// false before exiting to the event loop!
@ -76,41 +69,50 @@ function ImageListener(start_callback, stop_callback)
this.state = 0;
}
function NS_FAILED(val)
{
function NS_FAILED(val) {
return !!(val & 0x80000000);
}
function ChannelListener()
{
this.onStartRequest = function onStartRequest(aRequest)
{
if (this.outputListener)
function ChannelListener() {
this.onStartRequest = function onStartRequest(aRequest) {
if (this.outputListener) {
this.outputListener.onStartRequest(aRequest);
}
this.requestStatus |= START_REQUEST;
}
};
this.onDataAvailable = function onDataAvailable(aRequest, aInputStream, aOffset, aCount)
{
if (this.outputListener)
this.outputListener.onDataAvailable(aRequest, aInputStream, aOffset, aCount);
this.onDataAvailable = function onDataAvailable(
aRequest,
aInputStream,
aOffset,
aCount
) {
if (this.outputListener) {
this.outputListener.onDataAvailable(
aRequest,
aInputStream,
aOffset,
aCount
);
}
this.requestStatus |= DATA_AVAILABLE;
}
};
this.onStopRequest = function onStopRequest(aRequest, aStatusCode)
{
if (this.outputListener)
this.onStopRequest = function onStopRequest(aRequest, aStatusCode) {
if (this.outputListener) {
this.outputListener.onStopRequest(aRequest, aStatusCode);
}
// If we failed (or were canceled - failure is implied if canceled),
// there's no use tracking our state, since it's meaningless.
if (NS_FAILED(aStatusCode))
if (NS_FAILED(aStatusCode)) {
this.requestStatus = 0;
else
} else {
this.requestStatus |= STOP_REQUEST;
}
};
// A listener to pass the notifications we get to.
this.outputListener = null;

9
image/test/unit/test_async_notification.js
View file

@ -3,8 +3,11 @@
*/
// A simple 3x3 png; rows go red, green, blue. Stolen from the PNG encoder test.
var pngspec = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=";
var ioService = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
var pngspec =
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=";
var ioService = Cc["@mozilla.org/network/io-service;1"].getService(
Ci.nsIIOService
);
var uri = ioService.newURI(pngspec);
load('async_load_tests.js');
load("async_load_tests.js");

17
image/test/unit/test_async_notification_404.js
View file

@ -2,15 +2,20 @@
* Test to ensure that load/decode notifications are delivered completely and
* asynchronously when dealing with a file that's a 404.
*/
const {XPCOMUtils} = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
const { XPCOMUtils } = ChromeUtils.import(
"resource://gre/modules/XPCOMUtils.jsm"
);
var ioService = Cc["@mozilla.org/network/io-service;1"]
.getService(Ci.nsIIOService);
var ioService = Cc["@mozilla.org/network/io-service;1"].getService(
Ci.nsIIOService
);
XPCOMUtils.defineLazyGetter(this, "uri", function() {
return ioService.newURI("http://localhost:" +
return ioService.newURI(
"http://localhost:" +
server.identity.primaryPort +
"/async-notification-never-here.jpg");
"/async-notification-never-here.jpg"
);
});
load('async_load_tests.js');
load("async_load_tests.js");

9
image/test/unit/test_async_notification_animated.js
View file

@ -7,8 +7,11 @@
*/
// transparent-animation.gif from the gif reftests.
var spec = "data:image/gif;base64,R0lGODlhZABkAIABAP8AAP///yH5BAkBAAEALAAAAABLAGQAAAK8jI+py+0Po5y02ouz3rz7D4biSJbmiabqyrbuC8fyTNf2jef6zvf+DwwKh8Si8YhMKpchgPMJjUqnVOipis1ir9qul+sNV8HistVkTj/JajG7/UXDy+95tm4fy/NdPF/q93dWIqgVWAhwWKgoyPjnyAeZJ2lHOWcJh9mmqcaZ5mkGSreHOCXqRloadRrGGkeoapoa6+TaN0tra4gbq3vHq+q7BVwqrMeEnKy8zNzs/AwdLT1NXW19jZ1tUgAAIfkECQEAAQAsAAAAADQAZAAAArCMj6nL7Q+jnLTai7PevPsPhuJIluaJpurKtu4Lx/JM1/aN5/rO9/7vAAiHxKLxiCRCkswmc+mMSqHSapJqzSof2u4Q67WCw1MuOTs+N9Pqq7kdZcON8vk2aF+/88g6358HaCc4Rwhn2IaopnjGSOYYBukl2UWpZYm2x0enuXnX4NnXGQqAKTYaalqlWoZH+snwWsQah+pJ64Sr5ypbCvQLHCw8TFxsfIycrLzM3PxQAAAh+QQJAQABACwAAAAAGwBkAAACUIyPqcvtD6OctNqLs968+w+G4kiW5omm6sq27gTE8kzX9o3n+s73/g8MCofEovGITCqXzKbzCY1Kp9Sq9YrNarfcrvdrfYnH5LL5jE6r16sCADs=";
var ioService = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
var spec =
"data:image/gif;base64,R0lGODlhZABkAIABAP8AAP///yH5BAkBAAEALAAAAABLAGQAAAK8jI+py+0Po5y02ouz3rz7D4biSJbmiabqyrbuC8fyTNf2jef6zvf+DwwKh8Si8YhMKpchgPMJjUqnVOipis1ir9qul+sNV8HistVkTj/JajG7/UXDy+95tm4fy/NdPF/q93dWIqgVWAhwWKgoyPjnyAeZJ2lHOWcJh9mmqcaZ5mkGSreHOCXqRloadRrGGkeoapoa6+TaN0tra4gbq3vHq+q7BVwqrMeEnKy8zNzs/AwdLT1NXW19jZ1tUgAAIfkECQEAAQAsAAAAADQAZAAAArCMj6nL7Q+jnLTai7PevPsPhuJIluaJpurKtu4Lx/JM1/aN5/rO9/7vAAiHxKLxiCRCkswmc+mMSqHSapJqzSof2u4Q67WCw1MuOTs+N9Pqq7kdZcON8vk2aF+/88g6358HaCc4Rwhn2IaopnjGSOYYBukl2UWpZYm2x0enuXnX4NnXGQqAKTYaalqlWoZH+snwWsQah+pJ64Sr5ypbCvQLHCw8TFxsfIycrLzM3PxQAAAh+QQJAQABACwAAAAAGwBkAAACUIyPqcvtD6OctNqLs968+w+G4kiW5omm6sq27gTE8kzX9o3n+s73/g8MCofEovGITCqXzKbzCY1Kp9Sq9YrNarfcrvdrfYnH5LL5jE6r16sCADs=";
var ioService = Cc["@mozilla.org/network/io-service;1"].getService(
Ci.nsIIOService
);
var uri = ioService.newURI(spec);
load('async_load_tests.js');
load("async_load_tests.js");

1165
image/test/unit/test_encoder_apng.js
View file

File diff suppressed because it is too large Load diff

277
image/test/unit/test_encoder_png.js
View file

@ -11,19 +11,45 @@ var png1A = {
frames: [
{
width : 3, height : 3,
width: 3,
height: 3,
format : Ci.imgIEncoder.INPUT_FORMAT_RGB, stride : 9,
format: Ci.imgIEncoder.INPUT_FORMAT_RGB,
stride: 9,
pixels: [
255,0,0, 255,0,0, 255,0,0,
0,255,0, 0,255,0, 0,255,0,
0,0,255, 0,0,255, 0,0,255,
]
}
255,
0,
0,
255,
0,
0,
255,
0,
0,
0,
255,
0,
0,
255,
0,
0,
255,
0,
0,
0,
255,
0,
0,
255,
0,
0,
255,
],
expected : "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII="
},
],
expected:
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=",
};
var png1B = {
@ -34,19 +60,45 @@ var png1B = {
frames: [
{
width : 3, height : 3,
width: 3,
height: 3,
format : Ci.imgIEncoder.INPUT_FORMAT_RGB, stride : 9,
format: Ci.imgIEncoder.INPUT_FORMAT_RGB,
stride: 9,
pixels: [
255,0,0, 255,0,0, 255,0,0,
0,255,0, 0,255,0, 0,255,0,
0,0,255, 0,0,255, 0,0,255,
]
}
255,
0,
0,
255,
0,
0,
255,
0,
0,
0,
255,
0,
0,
255,
0,
0,
255,
0,
0,
0,
255,
0,
0,
255,
0,
0,
255,
],
expected : "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII="
},
],
expected:
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=",
};
var png2A = {
@ -56,19 +108,54 @@ var png2A = {
frames: [
{
width : 3, height : 3,
width: 3,
height: 3,
format : Ci.imgIEncoder.INPUT_FORMAT_RGBA, stride : 12,
format: Ci.imgIEncoder.INPUT_FORMAT_RGBA,
stride: 12,
pixels: [
255,0,0,255, 255,0,0,170, 255,0,0,85,
0,255,0,255, 0,255,0,170, 0,255,0,85,
0,0,255,255, 0,0,255,170, 0,0,255,85
]
}
255,
0,
0,
255,
255,
0,
0,
170,
255,
0,
0,
85,
0,
255,
0,
255,
0,
255,
0,
170,
0,
255,
0,
85,
0,
0,
255,
255,
0,
0,
255,
170,
0,
0,
255,
85,
],
expected : "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAYAAABWKLW/AAAAIElEQVQImSXJMQEAMAwEIUy+yZi8DmVFFBcjycn86GgPJw4O8v9DkkEAAAAASUVORK5CYII="
},
],
expected:
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAYAAABWKLW/AAAAIElEQVQImSXJMQEAMAwEIUy+yZi8DmVFFBcjycn86GgPJw4O8v9DkkEAAAAASUVORK5CYII=",
};
var png2B = {
@ -79,33 +166,67 @@ var png2B = {
frames: [
{
width : 3, height : 3,
width: 3,
height: 3,
format : Ci.imgIEncoder.INPUT_FORMAT_RGBA, stride : 12,
format: Ci.imgIEncoder.INPUT_FORMAT_RGBA,
stride: 12,
pixels: [
255,0,0,255, 255,0,0,170, 255,0,0,85,
0,255,0,255, 0,255,0,170, 0,255,0,85,
0,0,255,255, 0,0,255,170, 0,0,255,85
]
}
255,
0,
0,
255,
255,
0,
0,
170,
255,
0,
0,
85,
0,
255,
0,
255,
0,
255,
0,
170,
0,
255,
0,
85,
0,
0,
255,
255,
0,
0,
255,
170,
0,
0,
255,
85,
],
expected : "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII="
},
],
expected:
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=",
};
// Main test entry point.
function run_test() {
dump("Checking png1A...\n")
dump("Checking png1A...\n");
run_test_for(png1A);
dump("Checking png1B...\n")
dump("Checking png1B...\n");
run_test_for(png1B);
dump("Checking png2A...\n")
dump("Checking png2A...\n");
run_test_for(png2A);
dump("Checking png2B...\n")
dump("Checking png2B...\n");
run_test_for(png2B);
};
}
function run_test_for(input) {
var encoder, dataURL;
@ -116,11 +237,12 @@ function run_test_for(input) {
encoder = encodeImageAsync(input);
dataURL = makeDataURLFromAsync(encoder, "image/png", input.expected);
};
}
function encodeImage(input) {
var encoder = Cc["@mozilla.org/image/encoder;2?type=image/png"].createInstance();
var encoder = Cc[
"@mozilla.org/image/encoder;2?type=image/png"
].createInstance();
encoder.QueryInterface(Ci.imgIEncoder);
var options = "";
@ -129,26 +251,38 @@ function encodeImage(input) {
}
var frame = input.frames[0];
encoder.initFromData(frame.pixels, frame.pixels.length,
frame.width, frame.height, frame.stride,
frame.format, options);
encoder.initFromData(
frame.pixels,
frame.pixels.length,
frame.width,
frame.height,
frame.stride,
frame.format,
options
);
return encoder;
}
function _encodeImageAsyncFactory(frame, options, encoder)
{
function _encodeImageAsyncFactory(frame, options, encoder) {
function finishEncode() {
encoder.addImageFrame(frame.pixels, frame.pixels.length,
frame.width, frame.height, frame.stride,
frame.format, options);
encoder.addImageFrame(
frame.pixels,
frame.pixels.length,
frame.width,
frame.height,
frame.stride,
frame.format,
options
);
encoder.endImageEncode();
}
return finishEncode;
}
function encodeImageAsync(input)
{
var encoder = Cc["@mozilla.org/image/encoder;2?type=image/png"].createInstance();
function encodeImageAsync(input) {
var encoder = Cc[
"@mozilla.org/image/encoder;2?type=image/png"
].createInstance();
encoder.QueryInterface(Ci.imgIEncoder);
var options = "";
@ -157,14 +291,12 @@ function encodeImageAsync(input)
}
var frame = input.frames[0];
encoder.startImageEncode(frame.width, frame.height,
frame.format, options);
encoder.startImageEncode(frame.width, frame.height, frame.format, options);
do_timeout(50, _encodeImageAsyncFactory(frame, options, encoder));
return encoder;
}
function makeDataURL(encoder, mimetype) {
var rawStream = encoder.QueryInterface(Ci.nsIInputStream);
@ -184,25 +316,23 @@ function makeDataURLFromAsync(encoder, mimetype, expected) {
do_test_pending();
var rawStream = encoder.QueryInterface(Ci.nsIAsyncInputStream);
var currentThread = Cc["@mozilla.org/thread-manager;1"].getService().currentThread;
var currentThread = Cc["@mozilla.org/thread-manager;1"].getService()
.currentThread;
var bytes = [];
var binarystream = Cc["@mozilla.org/binaryinputstream;1"].createInstance();
binarystream.QueryInterface(Ci.nsIBinaryInputStream);
var asyncReader =
{
onInputStreamReady(stream)
{
var asyncReader = {
onInputStreamReady(stream) {
binarystream.setInputStream(stream);
var available = 0;
try {
available = stream.available();
} catch (e) {}
if (available > 0)
{
if (available > 0) {
bytes = bytes.concat(binarystream.readByteArray(available));
stream.asyncWait(this, 0, 0, currentThread);
} else {
@ -211,8 +341,7 @@ function makeDataURLFromAsync(encoder, mimetype, expected) {
Assert.equal(dataURL, expected);
do_test_finished();
}
}
},
};
rawStream.asyncWait(asyncReader, 0, 0, currentThread);
}
@ -220,15 +349,15 @@ function makeDataURLFromAsync(encoder, mimetype, expected) {
/* toBase64 copied from extensions/xml-rpc/src/nsXmlRpcClient.js */
/* Convert data (an array of integers) to a Base64 string. */
const toBase64Table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' +
'0123456789+/';
const base64Pad = '=';
const toBase64Table =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789+/";
const base64Pad = "=";
function toBase64(data) {
var result = '';
var result = "";
var length = data.length;
var i;
// Convert every three bytes to 4 ascii characters.
for (i = 0; i < (length - 2); i += 3) {
for (i = 0; i < length - 2; i += 3) {
result += toBase64Table[data[i] >> 2];
result += toBase64Table[((data[i] & 0x03) << 4) + (data[i + 1] >> 4)];
result += toBase64Table[((data[i + 1] & 0x0f) << 2) + (data[i + 2] >> 6)];
@ -239,7 +368,7 @@ function toBase64(data) {
if (length % 3) {
i = length - (length % 3);
result += toBase64Table[data[i] >> 2];
if ((length%3) == 2) {
if (length % 3 == 2) {
result += toBase64Table[((data[i] & 0x03) << 4) + (data[i + 1] >> 4)];
result += toBase64Table[(data[i + 1] & 0x0f) << 2];
result += base64Pad;

245
image/test/unit/test_imgtools.js
View file

@ -14,13 +14,15 @@ function dumpToFile(aData) {
var outputFile = do_get_tempdir();
outputFile.append("testdump.png");
var outputStream = Cc["@mozilla.org/network/file-output-stream;1"].
createInstance(Ci.nsIFileOutputStream);
var outputStream = Cc[
"@mozilla.org/network/file-output-stream;1"
].createInstance(Ci.nsIFileOutputStream);
// WR_ONLY|CREAT|TRUNC
outputStream.init(outputFile, 0x02 | 0x08 | 0x20, 0o644, null);
var bos = Cc["@mozilla.org/binaryoutputstream;1"].
createInstance(Ci.nsIBinaryOutputStream);
var bos = Cc["@mozilla.org/binaryoutputstream;1"].createInstance(
Ci.nsIBinaryOutputStream
);
bos.setOutputStream(outputStream);
bos.writeByteArray(aData, aData.length);
@ -28,28 +30,28 @@ function dumpToFile(aData) {
outputStream.close();
}
/*
* getFileInputStream()
*
* Returns an input stream for the specified file.
*/
function getFileInputStream(aFile) {
var inputStream = Cc["@mozilla.org/network/file-input-stream;1"].
createInstance(Ci.nsIFileInputStream);
var inputStream = Cc[
"@mozilla.org/network/file-input-stream;1"
].createInstance(Ci.nsIFileInputStream);
// init the stream as RD_ONLY, -1 == default permissions.
inputStream.init(aFile, 0x01, -1, null);
// Blah. The image decoders use ReadSegments, which isn't implemented on
// file input streams. Use a buffered stream to make it work.
var bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
createInstance(Ci.nsIBufferedInputStream);
var bis = Cc["@mozilla.org/network/buffered-input-stream;1"].createInstance(
Ci.nsIBufferedInputStream
);
bis.init(inputStream, 1024);
return bis;
}
/*
* streamToArray()
*
@ -59,18 +61,19 @@ function streamToArray(aStream) {
var size = aStream.available();
// use a binary input stream to grab the bytes.
var bis = Cc["@mozilla.org/binaryinputstream;1"].
createInstance(Ci.nsIBinaryInputStream);
var bis = Cc["@mozilla.org/binaryinputstream;1"].createInstance(
Ci.nsIBinaryInputStream
);
bis.setInputStream(aStream);
var bytes = bis.readByteArray(size);
if (size != bytes.length)
if (size != bytes.length) {
throw "Didn't read expected number of bytes";
}
return bytes;
}
/*
* compareArrays
*
@ -79,11 +82,12 @@ function streamToArray(aStream) {
function compareArrays(aArray1, aArray2) {
Assert.equal(aArray1.length, aArray2.length);
for (var i = 0; i < aArray1.length; i++)
if (aArray1[i] != aArray2[i])
for (var i = 0; i < aArray1.length; i++) {
if (aArray1[i] != aArray2[i]) {
throw "arrays differ at index " + i;
}
}
}
/*
* checkExpectedError
@ -93,11 +97,13 @@ function compareArrays(aArray1, aArray2) {
*/
function checkExpectedError(aExpectedError, aActualError) {
if (aExpectedError) {
if (!aActualError)
if (!aActualError) {
throw "Didn't throw as expected (" + aExpectedError + ")";
}
if (!aExpectedError.test(aActualError))
if (!aExpectedError.test(aActualError)) {
throw "Threw (" + aActualError + "), not (" + aExpectedError;
}
// We got the expected error, so make a note in the test log.
dump("...that error was expected.\n\n");
@ -106,22 +112,18 @@ function checkExpectedError (aExpectedError, aActualError) {
}
}
function run_test() {
try {
/* ========== 0 ========== */
var testnum = 0;
var testdesc = "imgITools setup";
var err = null;
var imgTools = Cc["@mozilla.org/image/tools;1"].
getService(Ci.imgITools);
var imgTools = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools);
if (!imgTools)
throw "Couldn't get imgITools service"
if (!imgTools) {
throw "Couldn't get imgITools service";
}
// Ugh, this is an ugly hack. The pixel values we get in Windows are sometimes
// +/- 1 value compared to other platforms, so we need to compare against a
@ -130,7 +132,6 @@ if (!imgTools)
// we're running on Windows.
var isWindows = mozinfo.os == "win";
/* ========== 1 ========== */
testnum++;
testdesc = "test decoding a PNG";
@ -144,15 +145,17 @@ var istream = getFileInputStream(imgFile);
Assert.equal(istream.available(), 8415);
var buffer = NetUtil.readInputStreamToString(istream, istream.available());
var container = imgTools.decodeImageFromBuffer(buffer, buffer.length,
inMimeType);
var container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
// It's not easy to look at the pixel values from JS, so just
// check the container's size.
Assert.equal(container.width, 64);
Assert.equal(container.height, 64);
/* ========== 2 ========== */
testnum++;
testdesc = "test encoding a scaled JPEG";
@ -171,7 +174,6 @@ var referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 3 ========== */
testnum++;
testdesc = "test encoding an unscaled JPEG";
@ -190,7 +192,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 4 ========== */
testnum++;
testdesc = "test decoding a JPEG";
@ -204,14 +205,17 @@ istream = getFileInputStream(imgFile);
Assert.equal(istream.available(), 3494);
buffer = NetUtil.readInputStreamToString(istream, istream.available());
container = imgTools.decodeImageFromBuffer(buffer, buffer.length, inMimeType);
container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
// It's not easy to look at the pixel values from JS, so just
// check the container's size.
Assert.equal(container.width, 32);
Assert.equal(container.height, 32);
/* ========== 5 ========== */
testnum++;
testdesc = "test encoding a scaled PNG";
@ -232,7 +236,6 @@ referenceBytes = streamToArray(istream);
compareArrays(encodedBytes, referenceBytes);
}
/* ========== 6 ========== */
testnum++;
testdesc = "test encoding an unscaled PNG";
@ -253,7 +256,6 @@ referenceBytes = streamToArray(istream);
compareArrays(encodedBytes, referenceBytes);
}
/* ========== 7 ========== */
testnum++;
testdesc = "test decoding a ICO";
@ -267,14 +269,17 @@ istream = getFileInputStream(imgFile);
Assert.equal(istream.available(), 1406);
buffer = NetUtil.readInputStreamToString(istream, istream.available());
container = imgTools.decodeImageFromBuffer(buffer, buffer.length, inMimeType);
container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
// It's not easy to look at the pixel values from JS, so just
// check the container's size.
Assert.equal(container.width, 16);
Assert.equal(container.height, 16);
/* ========== 8 ========== */
testnum++;
testdesc = "test encoding a scaled PNG"; // note that we're scaling UP
@ -293,7 +298,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 9 ========== */
testnum++;
testdesc = "test encoding an unscaled PNG";
@ -312,7 +316,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 10 ========== */
testnum++;
testdesc = "test decoding a GIF";
@ -326,7 +329,11 @@ istream = getFileInputStream(imgFile);
Assert.equal(istream.available(), 1809);
buffer = NetUtil.readInputStreamToString(istream, istream.available());
container = imgTools.decodeImageFromBuffer(buffer, buffer.length, inMimeType);
container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
// It's not easy to look at the pixel values from JS, so just
// check the container's size.
@ -335,13 +342,16 @@ Assert.equal(container.height, 32);
/* ========== 11 ========== */
testnum++;
testdesc = "test encoding an unscaled ICO with format options " +
testdesc =
"test encoding an unscaled ICO with format options " +
"(format=bmp;bpp=32)";
// we'll reuse the container from the previous test
istream = imgTools.encodeImage(container,
istream = imgTools.encodeImage(
container,
"image/vnd.microsoft.icon",
"format=bmp;bpp=32");
"format=bmp;bpp=32"
);
encodedBytes = streamToArray(istream);
// Get bytes for exected result
@ -356,15 +366,17 @@ compareArrays(encodedBytes, referenceBytes);
/* ========== 12 ========== */
testnum++;
testdesc = "test encoding a scaled ICO with format options " +
"(format=bmp;bpp=32)";
testdesc =
"test encoding a scaled ICO with format options " + "(format=bmp;bpp=32)";
// we'll reuse the container from the previous test
istream = imgTools.encodeScaledImage(container,
istream = imgTools.encodeScaledImage(
container,
"image/vnd.microsoft.icon",
16,
16,
"format=bmp;bpp=32");
"format=bmp;bpp=32"
);
encodedBytes = streamToArray(istream);
// Get bytes for exected result
@ -379,13 +391,16 @@ compareArrays(encodedBytes, referenceBytes);
/* ========== 13 ========== */
testnum++;
testdesc = "test encoding an unscaled ICO with format options " +
testdesc =
"test encoding an unscaled ICO with format options " +
"(format=bmp;bpp=24)";
// we'll reuse the container from the previous test
istream = imgTools.encodeImage(container,
istream = imgTools.encodeImage(
container,
"image/vnd.microsoft.icon",
"format=bmp;bpp=24");
"format=bmp;bpp=24"
);
encodedBytes = streamToArray(istream);
// Get bytes for exected result
@ -400,15 +415,17 @@ compareArrays(encodedBytes, referenceBytes);
/* ========== 14 ========== */
testnum++;
testdesc = "test encoding a scaled ICO with format options " +
"(format=bmp;bpp=24)";
testdesc =
"test encoding a scaled ICO with format options " + "(format=bmp;bpp=24)";
// we'll reuse the container from the previous test
istream = imgTools.encodeScaledImage(container,
istream = imgTools.encodeScaledImage(
container,
"image/vnd.microsoft.icon",
16,
16,
"format=bmp;bpp=24");
"format=bmp;bpp=24"
);
encodedBytes = streamToArray(istream);
// Get bytes for exected result
@ -421,7 +438,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 15 ========== */
testnum++;
testdesc = "test cropping a JPG";
@ -435,7 +451,11 @@ istream = getFileInputStream(imgFile);
Assert.equal(istream.available(), 3494);
buffer = NetUtil.readInputStreamToString(istream, istream.available());
container = imgTools.decodeImageFromBuffer(buffer, buffer.length, inMimeType);
container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
// It's not easy to look at the pixel values from JS, so just
// check the container's size.
@ -443,7 +463,14 @@ Assert.equal(container.width, 32);
Assert.equal(container.height, 32);
// encode a cropped image
istream = imgTools.encodeCroppedImage(container, "image/jpeg", 0, 0, 16, 16);
istream = imgTools.encodeCroppedImage(
container,
"image/jpeg",
0,
0,
16,
16
);
encodedBytes = streamToArray(istream);
// Get bytes for exected result
@ -456,13 +483,19 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 16 ========== */
testnum++;
testdesc = "test cropping a JPG with an offset";
// we'll reuse the container from the previous test
istream = imgTools.encodeCroppedImage(container, "image/jpeg", 16, 16, 16, 16);
istream = imgTools.encodeCroppedImage(
container,
"image/jpeg",
16,
16,
16,
16
);
encodedBytes = streamToArray(istream);
// Get bytes for exected result
@ -475,7 +508,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 17 ========== */
testnum++;
testdesc = "test cropping a JPG without a given height";
@ -494,7 +526,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 18 ========== */
testnum++;
testdesc = "test cropping a JPG without a given width";
@ -513,7 +544,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 19 ========== */
testnum++;
testdesc = "test cropping a JPG without a given width and height";
@ -532,7 +562,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 20 ========== */
testnum++;
testdesc = "test scaling a JPG without a given width";
@ -551,7 +580,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 21 ========== */
testnum++;
testdesc = "test scaling a JPG without a given height";
@ -570,7 +598,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 22 ========== */
testnum++;
testdesc = "test scaling a JPG without a given width and height";
@ -589,7 +616,6 @@ referenceBytes = streamToArray(istream);
// compare the encoder's output to the reference file.
compareArrays(encodedBytes, referenceBytes);
/* ========== 22 ========== */
testnum++;
testdesc = "test invalid arguments for cropping";
@ -599,49 +625,65 @@ var numErrors = 0;
try {
// width/height can't be negative
imgTools.encodeScaledImage(container, "image/jpeg", -1, -1);
} catch (e) { numErrors++; }
} catch (e) {
numErrors++;
}
try {
// offsets can't be negative
imgTools.encodeCroppedImage(container, "image/jpeg", -1, -1, 16, 16);
} catch (e) { numErrors++; }
} catch (e) {
numErrors++;
}
try {
// width/height can't be negative
imgTools.encodeCroppedImage(container, "image/jpeg", 0, 0, -1, -1);
} catch (e) { numErrors++; }
} catch (e) {
numErrors++;
}
try {
// out of bounds
imgTools.encodeCroppedImage(container, "image/jpeg", 17, 17, 16, 16);
} catch (e) { numErrors++; }
} catch (e) {
numErrors++;
}
try {
// out of bounds
imgTools.encodeCroppedImage(container, "image/jpeg", 0, 0, 33, 33);
} catch (e) { numErrors++; }
} catch (e) {
numErrors++;
}
try {
// out of bounds
imgTools.encodeCroppedImage(container, "image/jpeg", 1, 1, 0, 0);
} catch (e) { numErrors++; }
} catch (e) {
numErrors++;
}
Assert.equal(numErrors, 6);
/* ========== bug 363986 ========== */
testnum = 363986;
testdesc = "test PNG and JPEG encoders' Read/ReadSegments methods";
var testData =
[{preImage: "image3.ico",
var testData = [
{
preImage: "image3.ico",
preImageMimeType: "image/x-icon",
refImage: "image3ico16x16.png",
refImageMimeType: "image/png"},
{preImage: "image1.png",
refImageMimeType: "image/png",
},
{
preImage: "image1.png",
preImageMimeType: "image/png",
refImage: "image1png64x64.jpg",
refImageMimeType: "image/jpeg"}];
refImageMimeType: "image/jpeg",
},
];
for (var i = 0; i < testData.length; ++i) {
var dict = testData[i];
@ -653,31 +695,39 @@ for(var i=0; i<testData.length; ++i) {
imgFile = do_get_file(dict.preImage);
istream = getFileInputStream(imgFile);
var buffer = NetUtil.readInputStreamToString(istream, istream.available());
var container = imgTools.decodeImageFromBuffer(buffer, buffer.length,
dict.preImageMimeType);
var buffer = NetUtil.readInputStreamToString(
istream,
istream.available()
);
var container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
dict.preImageMimeType
);
istream = imgTools.encodeImage(container, dict.refImageMimeType);
var sstream = Cc["@mozilla.org/storagestream;1"].
createInstance(Ci.nsIStorageStream);
var sstream = Cc["@mozilla.org/storagestream;1"].createInstance(
Ci.nsIStorageStream
);
sstream.init(4096, 4294967295, null);
var ostream = sstream.getOutputStream(0);
var bostream = Cc["@mozilla.org/network/buffered-output-stream;1"].
createInstance(Ci.nsIBufferedOutputStream);
var bostream = Cc[
"@mozilla.org/network/buffered-output-stream;1"
].createInstance(Ci.nsIBufferedOutputStream);
// use a tiny buffer to make sure the image data doesn't fully fit in it
bostream.init(ostream, 8);
bostream.writeFrom(istream, istream.available());
bostream.flush(); bostream.close();
bostream.flush();
bostream.close();
var encBytes = streamToArray(sstream.newInputStream(0));
compareArrays(refBytes, encBytes);
}
/* ========== bug 413512 ========== */
testnum = 413512;
testdesc = "test decoding bad favicon (bug 413512)";
@ -692,7 +742,11 @@ var errsrc = "none";
try {
buffer = NetUtil.readInputStreamToString(istream, istream.available());
container = imgTools.decodeImageFromBuffer(buffer, buffer.length, inMimeType);
container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
// We expect to hit an error during encoding because the ICO header of the
// image is fine, but the actual resources are corrupt. Since
@ -713,7 +767,6 @@ try {
Assert.equal(errsrc, "encode");
checkExpectedError(/NS_ERROR_FAILURE/, err);
/* ========== bug 815359 ========== */
testnum = 815359;
testdesc = "test correct ico hotspots (bug 815359)";
@ -726,17 +779,19 @@ istream = getFileInputStream(imgFile);
Assert.equal(istream.available(), 4286);
buffer = NetUtil.readInputStreamToString(istream, istream.available());
container = imgTools.decodeImageFromBuffer(buffer, buffer.length, inMimeType);
container = imgTools.decodeImageFromBuffer(
buffer,
buffer.length,
inMimeType
);
var props = container.QueryInterface(Ci.nsIProperties);
Assert.equal(props.get("hotspotX", Ci.nsISupportsPRUint32).data, 10);
Assert.equal(props.get("hotspotY", Ci.nsISupportsPRUint32).data, 9);
/* ========== end ========== */
} catch (e) {
throw "FAILED in test #" + testnum + " -- " + testdesc + ": " + e;
}
};
}

12
image/test/unit/test_moz_icon_uri.js
View file

File diff suppressed because one or more lines are too long

84
image/test/unit/test_private_channel.js
View file

@ -3,16 +3,22 @@ const {NetUtil} = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
var server = new HttpServer();
server.registerPathHandler('/image.png', imageHandler);
server.registerPathHandler("/image.png", imageHandler);
server.start(-1);
load('image_load_helpers.js');
load("image_load_helpers.js");
var gHits = 0;
var gIoService = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
var gPublicLoader = Cc["@mozilla.org/image/loader;1"].createInstance(Ci.imgILoader);
var gPrivateLoader = Cc["@mozilla.org/image/loader;1"].createInstance(Ci.imgILoader);
var gIoService = Cc["@mozilla.org/network/io-service;1"].getService(
Ci.nsIIOService
);
var gPublicLoader = Cc["@mozilla.org/image/loader;1"].createInstance(
Ci.imgILoader
);
var gPrivateLoader = Cc["@mozilla.org/image/loader;1"].createInstance(
Ci.imgILoader
);
gPrivateLoader.QueryInterface(Ci.imgICache).respectPrivacyNotifications();
var nonPrivateLoadContext = Cu.createLoadContext();
@ -23,24 +29,30 @@ function imageHandler(metadata, response) {
response.setHeader("Cache-Control", "max-age=10000", false);
response.setStatusLine(metadata.httpVersion, 200, "OK");
response.setHeader("Content-Type", "image/png", false);
var body = "iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=";
var body =
"iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII=";
response.bodyOutputStream.write(body, body.length);
}
var requests = [];
var listeners = [];
var gImgPath = 'http://localhost:' + server.identity.primaryPort + '/image.png';
var gImgPath = "http://localhost:" + server.identity.primaryPort + "/image.png";
function setup_chan(path, isPrivate, callback) {
var uri = NetUtil.newURI(gImgPath);
var securityFlags = Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL;
var principal = Services.scriptSecurityManager
.createCodebasePrincipal(uri, {privateBrowsingId: isPrivate ? 1 : 0});
var chan = NetUtil.newChannel({uri, loadingPrincipal: principal,
var principal = Services.scriptSecurityManager.createCodebasePrincipal(uri, {
privateBrowsingId: isPrivate ? 1 : 0,
});
var chan = NetUtil.newChannel({
uri,
loadingPrincipal: principal,
securityFlags,
contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE});
chan.notificationCallbacks = isPrivate ? privateLoadContext
contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE,
});
chan.notificationCallbacks = isPrivate
? privateLoadContext
: nonPrivateLoadContext;
var channelListener = new ChannelListener();
chan.asyncOpen(channelListener);
@ -48,24 +60,44 @@ function setup_chan(path, isPrivate, callback) {
var listener = new ImageListener(null, callback);
var outlistener = {};
var loader = isPrivate ? gPrivateLoader : gPublicLoader;
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
listeners.push(outer);
requests.push(loader.loadImageWithChannelXPCOM(chan, outer, null, outlistener));
requests.push(
loader.loadImageWithChannelXPCOM(chan, outer, null, outlistener)
);
channelListener.outputListener = outlistener.value;
listener.synchronous = false;
}
function loadImage(isPrivate, callback) {
var listener = new ImageListener(null, callback);
var outer = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools)
var outer = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.createScriptedObserver(listener);
var uri = gIoService.newURI(gImgPath);
var loadGroup = Cc["@mozilla.org/network/load-group;1"].createInstance(Ci.nsILoadGroup);
loadGroup.notificationCallbacks = isPrivate ? privateLoadContext
var loadGroup = Cc["@mozilla.org/network/load-group;1"].createInstance(
Ci.nsILoadGroup
);
loadGroup.notificationCallbacks = isPrivate
? privateLoadContext
: nonPrivateLoadContext;
var loader = isPrivate ? gPrivateLoader : gPublicLoader;
requests.push(loader.loadImageXPCOM(uri, null, null, "default", null, loadGroup, outer, null, 0, null));
requests.push(
loader.loadImageXPCOM(
uri,
null,
null,
"default",
null,
loadGroup,
outer,
null,
0,
null
)
);
listener.synchronous = false;
}
@ -86,13 +118,13 @@ function run_loadImage_tests() {
}
Services.obs.addObserver(observer, "cacheservice:empty-cache");
let cs = Cc["@mozilla.org/netwerk/cache-storage-service;1"]
.getService(Ci.nsICacheStorageService);
let cs = Cc["@mozilla.org/netwerk/cache-storage-service;1"].getService(
Ci.nsICacheStorageService
);
cs.clear();
}
function cleanup()
{
function cleanup() {
for (var i = 0; i < requests.length; ++i) {
requests[i].cancelAndForgetObserver(0);
}
@ -110,10 +142,10 @@ function run_test() {
// and load the same image, and do that a second time to ensure a cache
// read. In total, we should cause two separate http responses to occur,
// since the private channels shouldn't be able to use the public cache.
setup_chan('/image.png', false, function() {
setup_chan('/image.png', false, function() {
setup_chan('/image.png', true, function() {
setup_chan('/image.png', true, function() {
setup_chan("/image.png", false, function() {
setup_chan("/image.png", false, function() {
setup_chan("/image.png", true, function() {
setup_chan("/image.png", true, function() {
Assert.equal(gHits, 2);
run_loadImage_tests();
});