Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test gets skipped with pattern: verify
- Manifest: dom/base/test/browser.toml
/* -*- Mode: javascript; tab-width: 2; indent-tabs-mode: nil; js-indent-level: 2 -*- */
requestLongerTimeout(2);
add_setup(async function test_initialize() {
await SpecialPowers.pushPrefEnv({
set: [
["layout.css.use-counters.enabled", true],
["layout.css.use-counters-unimplemented.enabled", true],
],
});
});
async function grabCounters(counters, before) {
let result = { sentinel: await ensureData(before?.sentinel) };
await Services.fog.testFlushAllChildren();
result.gleanPage = Object.fromEntries(
counters.map(c => [
c.name,
Glean[`useCounter${c.glean[0]}Page`][c.glean[1]].testGetValue() ?? 0,
])
);
result.gleanDoc = Object.fromEntries(
counters.map(c => [
c.name,
Glean[`useCounter${c.glean[0]}Doc`][c.glean[1]].testGetValue() ?? 0,
])
);
result.glean_docs_destroyed =
Glean.useCounter.contentDocumentsDestroyed.testGetValue();
result.glean_toplevel_destroyed =
Glean.useCounter.topLevelContentDocumentsDestroyed.testGetValue();
return result;
}
function assertRange(before, after, key, range) {
before = before[key];
after = after[key];
let desc = key + " are correct";
if (Array.isArray(range)) {
let [min, max] = range;
Assert.greaterOrEqual(after, before + min, desc);
Assert.lessOrEqual(after, before + max, desc);
} else {
Assert.equal(after, before + range, desc);
}
}
async function test_once(
{ counters, toplevel_docs, docs, ignore_sentinel },
callback
) {
// Hold on to the current values of the data we're interested in.
// Opening an about:blank tab shouldn't change those.
let before = await grabCounters(counters);
await callback();
let after = await grabCounters(counters, ignore_sentinel ? null : before);
// Compare before and after.
for (let counter of counters) {
let name = counter.name;
let value = counter.value ?? 1;
if (!counter.xfail) {
is(
after.gleanPage[name],
before.gleanPage[name] + value,
`Glean page counts for ${name} are correct`
);
is(
after.gleanDoc[name],
before.gleanDoc[name] + value,
`Glean document counts for ${name} are correct`
);
}
}
assertRange(before, after, "glean_toplevel_destroyed", toplevel_docs);
assertRange(before, after, "glean_docs_destroyed", docs);
}
add_task(async function test_page_counters() {
const TESTS = [
// Check that use counters are incremented by SVGs loaded directly in iframes.
{
type: "iframe",
filename: "file_use_counter_svg_getElementById.svg",
counters: [
{
name: "SVGSVGELEMENT_GETELEMENTBYID",
glean: ["", "svgsvgelementGetelementbyid"],
},
],
},
{
type: "iframe",
filename: "file_use_counter_svg_currentScale.svg",
counters: [
{
name: "SVGSVGELEMENT_CURRENTSCALE_getter",
glean: ["", "svgsvgelementCurrentscaleGetter"],
},
{
name: "SVGSVGELEMENT_CURRENTSCALE_setter",
glean: ["", "svgsvgelementCurrentscaleSetter"],
},
],
},
{
type: "iframe",
filename: "file_use_counter_style.html",
counters: [
// Check for longhands.
{
name: "CSS_PROPERTY_BackgroundImage",
glean: ["Css", "cssBackgroundImage"],
},
// Check for shorthands.
{ name: "CSS_PROPERTY_Padding", glean: ["Css", "cssPadding"] },
// Check for aliases.
{
name: "CSS_PROPERTY_MozAppearance",
glean: ["Css", "cssMozAppearance"],
},
// Check for counted unknown properties.
{
name: "CSS_PROPERTY_WebkitPaddingStart",
glean: ["Css", "webkitPaddingStart"],
},
],
},
// Check that even loads from the imglib cache update use counters. The
// images should still be there, because we just loaded them in the last
// set of tests. But we won't get updated counts for the document
// counters, because we won't be re-parsing the SVG documents.
{
type: "iframe",
filename: "file_use_counter_svg_getElementById.svg",
counters: [
{
name: "SVGSVGELEMENT_GETELEMENTBYID",
glean: ["", "svgsvgelementGetelementbyid"],
},
],
},
{
type: "iframe",
filename: "file_use_counter_svg_currentScale.svg",
counters: [
{
name: "SVGSVGELEMENT_CURRENTSCALE_getter",
glean: ["", "svgsvgelementCurrentscaleGetter"],
},
{
name: "SVGSVGELEMENT_CURRENTSCALE_setter",
glean: ["", "svgsvgelementCurrentscaleSetter"],
},
],
},
// Check that use counters are incremented by SVGs loaded as images.
// Note that SVG images are not permitted to execute script, so we can only
// check for properties here.
{
type: "img",
filename: "file_use_counter_svg_getElementById.svg",
counters: [{ name: "CSS_PROPERTY_Fill", glean: ["Css", "cssFill"] }],
},
{
type: "img",
filename: "file_use_counter_svg_currentScale.svg",
counters: [{ name: "CSS_PROPERTY_Fill", glean: ["Css", "cssFill"] }],
},
// Check that use counters are incremented by directly loading SVGs
// that reference patterns defined in another SVG file.
{
type: "direct",
filename: "file_use_counter_svg_fill_pattern.svg",
counters: [
{
name: "CSS_PROPERTY_FillOpacity",
glean: ["Css", "cssFillOpacity"],
xfail: true,
},
],
},
// Check that use counters are incremented by directly loading SVGs
// that reference patterns defined in the same file or in data: URLs.
{
type: "direct",
filename: "file_use_counter_svg_fill_pattern_internal.svg",
counters: [
{ name: "CSS_PROPERTY_FillOpacity", glean: ["Css", "cssFillOpacity"] },
],
},
// Check that use counters are incremented in a display:none iframe.
{
type: "undisplayed-iframe",
filename: "file_use_counter_svg_currentScale.svg",
counters: [
{
name: "SVGSVGELEMENT_CURRENTSCALE_getter",
glean: ["", "svgsvgelementCurrentscaleGetter"],
},
],
},
// Check that a document that comes out of the bfcache reports any new use
// counters recorded on it.
{
type: "direct",
filename: "file_use_counter_bfcache.html",
waitForExplicitFinish: true,
counters: [
{
name: "SVGSVGELEMENT_GETELEMENTBYID",
glean: ["", "svgsvgelementGetelementbyid"],
},
],
},
// // data: URLs don't correctly propagate to their referring document yet.
// {
// type: "direct",
// filename: "file_use_counter_svg_fill_pattern_data.svg",
// counters: [
// { name: "PROPERTY_FILL_OPACITY" },
// ],
// },
];
for (let test of TESTS) {
let file = test.filename;
info(`checking ${file} (${test.type})`);
let options = {
counters: test.counters,
// bfcache test navigates a bunch of times and thus creates multiple top
// level document entries, as expected. Whether the last document is
// with +/- 1.
toplevel_docs: file == "file_use_counter_bfcache.html" ? [5, 6] : 1,
docs: [test.type == "img" ? 2 : 1, Infinity],
};
await test_once(options, async function () {
// Load the test file in the new tab, either directly or via
// file_use_counter_outer{,_display_none}.html, depending on the test type.
let url, targetElement;
switch (test.type) {
case "iframe":
url = gHttpTestRoot + "file_use_counter_outer.html";
targetElement = "content";
break;
case "undisplayed-iframe":
url = gHttpTestRoot + "file_use_counter_outer_display_none.html";
targetElement = "content";
break;
case "img":
url = gHttpTestRoot + "file_use_counter_outer.html";
targetElement = "display";
break;
case "direct":
url = gHttpTestRoot + file;
targetElement = null;
break;
default:
throw `unexpected type ${test.type}`;
}
let waitForFinish = null;
if (test.waitForExplicitFinish) {
is(
test.type,
"direct",
`cannot use waitForExplicitFinish with test type ${test.type}`
);
// Wait until the tab changes its hash to indicate it has finished.
waitForFinish = BrowserTestUtils.waitForLocationChange(
gBrowser,
url + "#finished"
);
}
let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
if (waitForFinish) {
await waitForFinish;
}
if (targetElement) {
// Inject our desired file into the target element of the newly-loaded page.
await SpecialPowers.spawn(
gBrowser.selectedBrowser,
[{ file, targetElement }],
function (opts) {
let target = content.document.getElementById(opts.targetElement);
target.src = opts.file;
return new Promise(resolve => {
let listener = event => {
event.target.removeEventListener("load", listener, true);
resolve();
};
target.addEventListener("load", listener, true);
});
}
);
}
// Tear down the page.
await BrowserTestUtils.removeTab(newTab);
});
}
});
add_task(async function test_extension_counters() {
let options = {
counters: [],
docs: 0,
toplevel_docs: 0,
ignore_sentinel: true,
};
await test_once(options, async function () {
let extension = ExtensionTestUtils.loadExtension({
manifest: {
page_action: {
default_popup: "page.html",
browser_style: false,
},
},
async background() {
let [tab] = await browser.tabs.query({
active: true,
currentWindow: true,
});
await browser.pageAction.show(tab.id);
browser.test.sendMessage("ready");
},
files: {
"page.html": `<!DOCTYPE html>
<meta charset="utf-8">
<!-- Enough to trigger the use counter -->
<style>:root { opacity: .5 }</style>
`,
},
});
await extension.startup();
info("Extension started up");
await extension.awaitMessage("ready");
await extension.unload();
info("Extension unloaded");
});
});
async function ensureData(prevSentinelValue = null) {
ok(
!prevSentinelValue ||
("page" in prevSentinelValue && "doc" in prevSentinelValue),
`Sentinel's valid: ${JSON.stringify(prevSentinelValue)}`
);
// Unfortunately, document destruction (when use counter reporting happens)
// happens at some time later than the removal of the tab.
// To wait for the use counters to be reported, we repeatedly flush IPC and
// check for a change in the "sentinel" use counters
// `use.counter.css.{page|doc}.css_marker_mid`.
return BrowserTestUtils.waitForCondition(
async () => {
await Services.fog.testFlushAllChildren();
return (
!prevSentinelValue ||
(prevSentinelValue?.page !=
Glean.useCounterCssPage.cssMarkerMid.testGetValue() &&
prevSentinelValue?.doc !=
Glean.useCounterCssDoc.cssMarkerMid.testGetValue())
);
},
"ensureData",
100,
Infinity
).then(
() => ({
doc: Glean.useCounterCssPage.cssMarkerMid.testGetValue(),
page: Glean.useCounterCssDoc.cssMarkerMid.testGetValue(),
}),
msg => {
throw msg;
}
);
}