mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
614 lines
23 KiB
XML
614 lines
23 KiB
XML
<?xml version="1.0"?>
|
|
<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
|
|
<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
|
|
<window title="about:memory"
|
|
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
|
|
<script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
|
|
<script type="text/javascript" src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"></script>
|
|
|
|
<!-- test results are displayed in the html:body -->
|
|
<body xmlns="http://www.w3.org/1999/xhtml"></body>
|
|
|
|
<!-- test code goes here -->
|
|
<script type="application/javascript">
|
|
<![CDATA[
|
|
const Cc = Components.classes;
|
|
const Ci = Components.interfaces;
|
|
var mgr = Cc["@mozilla.org/memory-reporter-manager;1"].
|
|
getService(Ci.nsIMemoryReporterManager);
|
|
|
|
// Access mgr.explicit and mgr.resident just to make sure they don't crash.
|
|
// We can't check their actual values because they're non-deterministic.
|
|
var dummy = mgr.explicit;
|
|
dummy = mgr.resident;
|
|
|
|
// Remove all the real reporters and multi-reporters; save them to
|
|
// restore at the end.
|
|
var e = mgr.enumerateReporters();
|
|
var realReporters = [];
|
|
dummy = 0;
|
|
while (e.hasMoreElements()) {
|
|
var r = e.getNext().QueryInterface(Ci.nsIMemoryReporter);
|
|
// Get the |amount| field, even though we don't use it, just to test
|
|
// that the reporter doesn't crash or anything.
|
|
dummy += r.amount;
|
|
mgr.unregisterReporter(r);
|
|
realReporters.push(r);
|
|
}
|
|
e = mgr.enumerateMultiReporters();
|
|
var realMultiReporters = [];
|
|
var dummy = 0;
|
|
while (e.hasMoreElements()) {
|
|
var r = e.getNext().QueryInterface(Ci.nsIMemoryMultiReporter);
|
|
// Call collectReports, even though we don't use its results, just to
|
|
// test that the multi-reporter doesn't crash or anything. And likewise
|
|
// for the |explicitNonHeap| field.
|
|
r.collectReports(function(){}, null);
|
|
dummy += r.explicitNonHeap;
|
|
mgr.unregisterMultiReporter(r);
|
|
realMultiReporters.push(r);
|
|
}
|
|
|
|
// Setup various fake-but-deterministic reporters.
|
|
const KB = 1024;
|
|
const MB = KB * KB;
|
|
const kUnknown = -1;
|
|
const NONHEAP = Ci.nsIMemoryReporter.KIND_NONHEAP;
|
|
const HEAP = Ci.nsIMemoryReporter.KIND_HEAP;
|
|
const OTHER = Ci.nsIMemoryReporter.KIND_OTHER;
|
|
|
|
const BYTES = Ci.nsIMemoryReporter.UNITS_BYTES;
|
|
const COUNT = Ci.nsIMemoryReporter.UNITS_COUNT;
|
|
const COUNT_CUMULATIVE = Ci.nsIMemoryReporter.UNITS_COUNT_CUMULATIVE;
|
|
const PERCENTAGE = Ci.nsIMemoryReporter.UNITS_PERCENTAGE;
|
|
|
|
function f2(aProcess, aPath, aKind, aUnits, aAmount) {
|
|
return {
|
|
process: aProcess,
|
|
path: aPath,
|
|
kind: aKind,
|
|
units: aUnits,
|
|
description: "(description)",
|
|
amount: aAmount
|
|
};
|
|
}
|
|
|
|
function f(aProcess, aPath, aKind, aAmount) {
|
|
return f2(aProcess, aPath, aKind, BYTES, aAmount);
|
|
}
|
|
|
|
var fakeReporters = [
|
|
f("", "heap-allocated", OTHER, 500 * MB),
|
|
f("", "heap-unallocated", OTHER, 100 * MB),
|
|
f("", "explicit/a", HEAP, 222 * MB),
|
|
f("", "explicit/b/a", HEAP, 85 * MB),
|
|
f("", "explicit/b/b", HEAP, 75 * MB),
|
|
f("", "explicit/b/c/a", HEAP, 70 * MB),
|
|
f("", "explicit/b/c/b", HEAP, 2 * MB), // omitted
|
|
f("", "explicit/g/a", HEAP, 6 * MB),
|
|
f("", "explicit/g/b", HEAP, 5 * MB),
|
|
f("", "explicit/g/other", HEAP, 4 * MB),
|
|
f("", "other1", OTHER, 111 * MB),
|
|
f2("", "other4", OTHER, COUNT_CUMULATIVE, 888)
|
|
];
|
|
var fakeMultiReporters = [
|
|
{ name: "fake1",
|
|
collectReports: function(cbObj, closure) {
|
|
function f(p, k, u, a) { cbObj.callback("", p, k, u, a, "(desc)", closure); }
|
|
f("explicit/c/d", NONHEAP, BYTES, 13 * MB),
|
|
f("explicit/c/d", NONHEAP, BYTES, 10 * MB), // dup
|
|
f("explicit/c/other", NONHEAP, BYTES, 77 * MB),
|
|
f("explicit/cc", NONHEAP, BYTES, 13 * MB);
|
|
f("explicit/cc", NONHEAP, BYTES, 10 * MB); // dup
|
|
f("explicit/d", NONHEAP, BYTES, 499 * KB); // omitted
|
|
f("explicit/e", NONHEAP, BYTES, 100 * KB); // omitted
|
|
f("explicit/f/g/h/i", HEAP, BYTES, 20 * MB);
|
|
},
|
|
explicitNonHeap: (100 + 13 + 10)*MB + (499 + 100)*KB
|
|
},
|
|
{ name: "fake2",
|
|
collectReports: function(cbObj, closure) {
|
|
function f(p, k, u, a) { cbObj.callback("", p, k, u, a, "(desc)", closure); }
|
|
f("other3", OTHER, COUNT, 777);
|
|
f("other2", OTHER, BYTES, 222 * MB);
|
|
f("perc2", OTHER, PERCENTAGE, 10000);
|
|
f("perc1", OTHER, PERCENTAGE, 4567);
|
|
},
|
|
explicitNonHeap: 0
|
|
},
|
|
{ name: "smaps",
|
|
collectReports: function(cbObj, closure) {
|
|
// The amounts are given in pages, so multiply here by 4kb.
|
|
function f(p, a) { cbObj.callback("", p, NONHEAP, BYTES, a * 4 * KB, "(desc)", closure); }
|
|
f("smaps/vsize/a", 24);
|
|
f("smaps/swap/a", 1);
|
|
f("smaps/swap/a", 2);
|
|
f("smaps/vsize/a", 19);
|
|
f("smaps/swap/b/c", 10);
|
|
f("smaps/resident/a", 42);
|
|
f("smaps/pss/a", 43);
|
|
},
|
|
explicitNonHeap: 0
|
|
}
|
|
];
|
|
for (var i = 0; i < fakeReporters.length; i++) {
|
|
mgr.registerReporter(fakeReporters[i]);
|
|
}
|
|
for (var i = 0; i < fakeMultiReporters.length; i++) {
|
|
mgr.registerMultiReporter(fakeMultiReporters[i]);
|
|
}
|
|
|
|
// mgr.explicit sums "heap-allocated" and all the appropriate NONHEAP ones:
|
|
// - "explicit/c", "explicit/cc" x 2, "explicit/d", "explicit/e"
|
|
// - but *not* "explicit/c/d" x 2
|
|
// Check explicit now before we add the fake reporters for the fake 2nd
|
|
// and subsequent processes.
|
|
is(mgr.explicit, 500*MB + (100 + 13 + 10)*MB + 599*KB, "mgr.explicit");
|
|
|
|
var fakeReporters2 = [
|
|
f("2nd", "heap-allocated", OTHER, 1000 * MB),
|
|
f("2nd", "heap-unallocated",OTHER, 100 * MB),
|
|
f("2nd", "explicit/a/b/c", HEAP, 497 * MB),
|
|
f("2nd", "explicit/a/b/c", HEAP, 1 * MB), // dup: merge
|
|
f("2nd", "explicit/a/b/c", HEAP, 1 * MB), // dup: merge
|
|
f("2nd", "explicit/flip\\the\\backslashes",
|
|
HEAP, 200 * MB),
|
|
f("2nd", "explicit/compartment(compartment-url)",
|
|
HEAP, 200 * MB),
|
|
// The escaping of compartment names must prevent this script from running.
|
|
f("2nd", "danger<script>window.alert(1)</script>",
|
|
OTHER, 666 * MB),
|
|
f("2nd", "other1", OTHER, 111 * MB),
|
|
|
|
// kUnknown should be handled gracefully for "heap-allocated", non-leaf
|
|
// reporters, leaf-reporters, "other" reporters, and duplicated reporters.
|
|
f("3rd", "heap-allocated", OTHER, kUnknown),
|
|
f("3rd", "explicit/a/b", HEAP, 333 * MB),
|
|
f("3rd", "explicit/a/c", HEAP, 444 * MB),
|
|
f("3rd", "explicit/a/c", HEAP, kUnknown), // dup: merge
|
|
f("3rd", "explicit/a/d", HEAP, kUnknown),
|
|
f("3rd", "explicit/a/d", HEAP, kUnknown), // dup: merge
|
|
f("3rd", "explicit/b", NONHEAP, kUnknown),
|
|
f2("3rd", "other1", OTHER, BYTES, kUnknown),
|
|
f2("3rd", "other2", OTHER, COUNT, kUnknown),
|
|
f2("3rd", "other3", OTHER, COUNT_CUMULATIVE, kUnknown),
|
|
f2("3rd", "other4", OTHER, PERCENTAGE, kUnknown),
|
|
|
|
// Invalid values (negative, too-big) should be identified.
|
|
f("4th", "heap-allocated", OTHER, 100 * MB),
|
|
f("4th", "explicit/js/compartment(http:\\\\too-big.com\\)/stuff",
|
|
HEAP, 150 * MB),
|
|
f("4th", "explicit/ok", HEAP, 5 * MB),
|
|
f("4th", "explicit/neg1", NONHEAP, -2 * MB),
|
|
// -111 becomes "-0.00MB" in non-verbose mode, and getting the negative
|
|
// sign in there correctly is non-trivial.
|
|
f2("4th", "other1", OTHER, BYTES, -111),
|
|
f2("4th", "other2", OTHER, BYTES, -222 * MB),
|
|
f2("4th", "other3", OTHER, COUNT, -333),
|
|
f2("4th", "other4", OTHER, COUNT_CUMULATIVE, -444),
|
|
f2("4th", "other5", OTHER, PERCENTAGE, -555),
|
|
// Escaping should again prevent this script from running when the name
|
|
// is printed in the warning.
|
|
f2("4th", "other6-danger<script>window.alert(1)</script>",
|
|
OTHER, PERCENTAGE, 66666),
|
|
|
|
// If a negative value is within a collapsed sub-tree in non-verbose mode,
|
|
// we should get the warning at the top and the relevant sub-trees should
|
|
// be expanded, even in non-verbose mode.
|
|
f("5th", "heap-allocated", OTHER, 100 * MB),
|
|
f("5th", "explicit/big", HEAP, 99 * MB),
|
|
f("5th", "explicit/a/pos", HEAP, 40 * KB),
|
|
f("5th", "explicit/a/neg1", NONHEAP, -20 * KB),
|
|
f("5th", "explicit/a/neg2", NONHEAP, -10 * KB),
|
|
f("5th", "explicit/b/c/d/e", NONHEAP, 20 * KB),
|
|
f("5th", "explicit/b/c/d/f", NONHEAP, -60 * KB),
|
|
f("5th", "explicit/b/c/g/h", NONHEAP, 10 * KB),
|
|
f("5th", "explicit/b/c/i/j", NONHEAP, 5 * KB)
|
|
];
|
|
var fakeMultiReporters2 = [
|
|
// Because this multi-reporter is in a child process, the fact that we
|
|
// skip the "smaps" multi-reporter in the parent process won't cause
|
|
// these to be skipped; the fall-back skipping will be hit instead.
|
|
{ name: "smaps",
|
|
collectReports: function(cbObj, closure) {
|
|
// The amounts are given in pages, so multiply here by 4kb.
|
|
function f(p, a) { cbObj.callback("2nd", p, NONHEAP, BYTES, a * 4 * KB, "(desc)", closure); }
|
|
f("smaps/vsize/a", 24);
|
|
f("smaps/vsize/b", 24);
|
|
},
|
|
explicitNonHeap: 0
|
|
}
|
|
];
|
|
for (var i = 0; i < fakeReporters2.length; i++) {
|
|
mgr.registerReporter(fakeReporters2[i]);
|
|
}
|
|
for (var i = 0; i < fakeMultiReporters2.length; i++) {
|
|
mgr.registerMultiReporter(fakeMultiReporters2[i]);
|
|
}
|
|
fakeReporters = fakeReporters.concat(fakeReporters2);
|
|
fakeMultiReporters = fakeMultiReporters.concat(fakeMultiReporters2);
|
|
]]>
|
|
</script>
|
|
|
|
<iframe id="amFrame" height="400" src="about:memory"></iframe>
|
|
<iframe id="amvFrame" height="400" src="about:memory?verbose"></iframe>
|
|
|
|
<script type="application/javascript">
|
|
<![CDATA[
|
|
var amExpectedText =
|
|
"\
|
|
Main Process\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
623.58 MB (100.0%) -- explicit\n\
|
|
├──232.00 MB (37.20%) -- b\n\
|
|
│ ├───85.00 MB (13.63%) ── a\n\
|
|
│ ├───75.00 MB (12.03%) ── b\n\
|
|
│ └───72.00 MB (11.55%) -- c\n\
|
|
│ ├──70.00 MB (11.23%) ── a\n\
|
|
│ └───2.00 MB (00.32%) ── b\n\
|
|
├──222.00 MB (35.60%) ── a\n\
|
|
├──100.00 MB (16.04%) -- c\n\
|
|
│ ├───77.00 MB (12.35%) ── other\n\
|
|
│ └───23.00 MB (03.69%) ── d [2]\n\
|
|
├───23.00 MB (03.69%) ── cc [2]\n\
|
|
├───20.00 MB (03.21%) -- f\n\
|
|
│ └──20.00 MB (03.21%) -- g\n\
|
|
│ └──20.00 MB (03.21%) -- h\n\
|
|
│ └──20.00 MB (03.21%) ── i\n\
|
|
├───15.00 MB (02.41%) ++ g\n\
|
|
├───11.00 MB (01.76%) ── heap-unclassified\n\
|
|
└────0.58 MB (00.09%) ++ (2 tiny)\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
500.00 MB ── heap-allocated\n\
|
|
100.00 MB ── heap-unallocated\n\
|
|
111.00 MB ── other1\n\
|
|
222.00 MB ── other2\n\
|
|
777 ── other3\n\
|
|
888 ── other4\n\
|
|
45.67% ── perc1\n\
|
|
100.00% ── perc2\n\
|
|
\n\
|
|
2nd Process\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
1,000.00 MB (100.0%) -- explicit\n\
|
|
├────499.00 MB (49.90%) -- a\n\
|
|
│ └──499.00 MB (49.90%) -- b\n\
|
|
│ └──499.00 MB (49.90%) ── c [3]\n\
|
|
├────200.00 MB (20.00%) ── flip/the/backslashes\n\
|
|
├────200.00 MB (20.00%) ── compartment(compartment-url)\n\
|
|
└────101.00 MB (10.10%) ── heap-unclassified\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
666.00 MB ── danger<script>window.alert(1)</script>\n\
|
|
1,000.00 MB ── heap-allocated\n\
|
|
100.00 MB ── heap-unallocated\n\
|
|
111.00 MB ── other1\n\
|
|
\n\
|
|
3rd Process\n\
|
|
\n\
|
|
WARNING: the 'heap-allocated' memory reporter does not work for this platform and/or configuration. This means that 'heap-unclassified' is zero and the 'explicit' tree shows less memory than it should.\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
777.00 MB (100.0%) -- explicit\n\
|
|
├──777.00 MB (100.0%) -- a\n\
|
|
│ ├──444.00 MB (57.14%) ── c [2]\n\
|
|
│ ├──333.00 MB (42.86%) ── b\n\
|
|
│ └────0.00 MB (00.00%) ── d [*] [2]\n\
|
|
└────0.00 MB (00.00%) ++ (2 tiny)\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
0.00 MB ── heap-allocated [*]\n\
|
|
0.00 MB ── other1 [*]\n\
|
|
0 ── other2 [*]\n\
|
|
0 ── other3 [*]\n\
|
|
0.00% ── other4 [*]\n\
|
|
\n\
|
|
4th Process\n\
|
|
\n\
|
|
WARNING: the following values are negative or unreasonably large.\n\
|
|
explicit/js\n\
|
|
explicit/js/compartment(http://too-big.com/)\n\
|
|
explicit/js/compartment(http://too-big.com/)/stuff\n\
|
|
explicit/(2 tiny)\n\
|
|
explicit/(2 tiny)/neg1\n\
|
|
explicit/(2 tiny)/heap-unclassified\n\
|
|
other1\n\
|
|
other2\n\
|
|
other3\n\
|
|
other4\n\
|
|
other5\n\
|
|
other6-danger<script>window.alert(1)</script>\n\
|
|
This indicates a defect in one or more memory reporters. The invalid values are highlighted.\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
98.00 MB (100.0%) -- explicit\n\
|
|
├──150.00 MB (153.06%) -- js [?!]\n\
|
|
│ └──150.00 MB (153.06%) -- compartment(http://too-big.com/) [?!]\n\
|
|
│ └──150.00 MB (153.06%) ── stuff [?!]\n\
|
|
├───5.00 MB (05.10%) ── ok\n\
|
|
└──-57.00 MB (-58.16%) -- (2 tiny) [?!]\n\
|
|
├───-2.00 MB (-2.04%) ── neg1 [?!]\n\
|
|
└──-55.00 MB (-56.12%) ── heap-unclassified [?!]\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
100.00 MB ── heap-allocated\n\
|
|
-0.00 MB ── other1 [?!]\n\
|
|
-222.00 MB ── other2 [?!]\n\
|
|
-333 ── other3 [?!]\n\
|
|
-444 ── other4 [?!]\n\
|
|
-5.55% ── other5 [?!]\n\
|
|
666.66% ── other6-danger<script>window.alert(1)</script> [?!]\n\
|
|
\n\
|
|
5th Process\n\
|
|
\n\
|
|
WARNING: the following values are negative or unreasonably large.\n\
|
|
explicit/(3 tiny)/a/neg2\n\
|
|
explicit/(3 tiny)/a/neg1\n\
|
|
explicit/(3 tiny)/b\n\
|
|
explicit/(3 tiny)/b/c\n\
|
|
explicit/(3 tiny)/b/c/d\n\
|
|
explicit/(3 tiny)/b/c/d/f\n\
|
|
This indicates a defect in one or more memory reporters. The invalid values are highlighted.\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
99.95 MB (100.0%) -- explicit\n\
|
|
├──99.00 MB (99.05%) ── big\n\
|
|
└───0.95 MB (00.95%) -- (3 tiny)\n\
|
|
├──0.96 MB (00.96%) ── heap-unclassified\n\
|
|
├──0.01 MB (00.01%) -- a\n\
|
|
│ ├──0.04 MB (00.04%) ── pos\n\
|
|
│ ├──-0.01 MB (-0.01%) ── neg2 [?!]\n\
|
|
│ └──-0.02 MB (-0.02%) ── neg1 [?!]\n\
|
|
└──-0.02 MB (-0.02%) -- b [?!]\n\
|
|
└──-0.02 MB (-0.02%) -- c [?!]\n\
|
|
├───0.01 MB (00.01%) ++ g\n\
|
|
├───0.00 MB (00.00%) ++ i\n\
|
|
└──-0.04 MB (-0.04%) -- d [?!]\n\
|
|
├───0.02 MB (00.02%) ── e\n\
|
|
└──-0.06 MB (-0.06%) ── f [?!]\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
100.00 MB ── heap-allocated\n\
|
|
\n\
|
|
";
|
|
|
|
var amvExpectedText =
|
|
"\
|
|
Main Process\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
653,876,224 B (100.0%) -- explicit\n\
|
|
├──243,269,632 B (37.20%) -- b\n\
|
|
│ ├───89,128,960 B (13.63%) ── a\n\
|
|
│ ├───78,643,200 B (12.03%) ── b\n\
|
|
│ └───75,497,472 B (11.55%) -- c\n\
|
|
│ ├──73,400,320 B (11.23%) ── a\n\
|
|
│ └───2,097,152 B (00.32%) ── b\n\
|
|
├──232,783,872 B (35.60%) ── a\n\
|
|
├──104,857,600 B (16.04%) -- c\n\
|
|
│ ├───80,740,352 B (12.35%) ── other\n\
|
|
│ └───24,117,248 B (03.69%) ── d [2]\n\
|
|
├───24,117,248 B (03.69%) ── cc [2]\n\
|
|
├───20,971,520 B (03.21%) -- f\n\
|
|
│ └──20,971,520 B (03.21%) -- g\n\
|
|
│ └──20,971,520 B (03.21%) -- h\n\
|
|
│ └──20,971,520 B (03.21%) ── i\n\
|
|
├───15,728,640 B (02.41%) -- g\n\
|
|
│ ├───6,291,456 B (00.96%) ── a\n\
|
|
│ ├───5,242,880 B (00.80%) ── b\n\
|
|
│ └───4,194,304 B (00.64%) ── other\n\
|
|
├───11,534,336 B (01.76%) ── heap-unclassified\n\
|
|
├──────510,976 B (00.08%) ── d\n\
|
|
└──────102,400 B (00.02%) ── e\n\
|
|
\n\
|
|
Resident Set Size (RSS) Breakdown\n\
|
|
172,032 B (100.0%) ++ resident\n\
|
|
\n\
|
|
Proportional Set Size (PSS) Breakdown\n\
|
|
176,128 B (100.0%) ++ pss\n\
|
|
\n\
|
|
Virtual Size Breakdown\n\
|
|
176,128 B (100.0%) ++ vsize\n\
|
|
\n\
|
|
Swap Usage Breakdown\n\
|
|
53,248 B (100.0%) ++ swap\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
524,288,000 B ── heap-allocated\n\
|
|
104,857,600 B ── heap-unallocated\n\
|
|
116,391,936 B ── other1\n\
|
|
232,783,872 B ── other2\n\
|
|
777 ── other3\n\
|
|
888 ── other4\n\
|
|
45.67% ── perc1\n\
|
|
100.00% ── perc2\n\
|
|
\n\
|
|
2nd Process\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
1,048,576,000 B (100.0%) -- explicit\n\
|
|
├────523,239,424 B (49.90%) -- a\n\
|
|
│ └──523,239,424 B (49.90%) -- b\n\
|
|
│ └──523,239,424 B (49.90%) ── c [3]\n\
|
|
├────209,715,200 B (20.00%) ── flip/the/backslashes\n\
|
|
├────209,715,200 B (20.00%) ── compartment(compartment-url)\n\
|
|
└────105,906,176 B (10.10%) ── heap-unclassified\n\
|
|
\n\
|
|
Virtual Size Breakdown\n\
|
|
196,608 B (100.0%) ++ vsize\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
698,351,616 B ── danger<script>window.alert(1)</script>\n\
|
|
1,048,576,000 B ── heap-allocated\n\
|
|
104,857,600 B ── heap-unallocated\n\
|
|
116,391,936 B ── other1\n\
|
|
\n\
|
|
3rd Process\n\
|
|
\n\
|
|
WARNING: the 'heap-allocated' memory reporter does not work for this platform and/or configuration. This means that 'heap-unclassified' is zero and the 'explicit' tree shows less memory than it should.\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
814,743,552 B (100.0%) -- explicit\n\
|
|
├──814,743,552 B (100.0%) -- a\n\
|
|
│ ├──465,567,744 B (57.14%) ── c [2]\n\
|
|
│ ├──349,175,808 B (42.86%) ── b\n\
|
|
│ └────────────0 B (00.00%) ── d [*] [2]\n\
|
|
├────────────0 B (00.00%) ── b [*]\n\
|
|
└────────────0 B (00.00%) ── heap-unclassified [*]\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
0 B ── heap-allocated [*]\n\
|
|
0 B ── other1 [*]\n\
|
|
0 ── other2 [*]\n\
|
|
0 ── other3 [*]\n\
|
|
0.00% ── other4 [*]\n\
|
|
\n\
|
|
4th Process\n\
|
|
\n\
|
|
WARNING: the following values are negative or unreasonably large.\n\
|
|
explicit/js\n\
|
|
explicit/js/compartment(http://too-big.com/)\n\
|
|
explicit/js/compartment(http://too-big.com/)/stuff\n\
|
|
explicit/neg1\n\
|
|
explicit/heap-unclassified\n\
|
|
other1\n\
|
|
other2\n\
|
|
other3\n\
|
|
other4\n\
|
|
other5\n\
|
|
other6-danger<script>window.alert(1)</script>\n\
|
|
This indicates a defect in one or more memory reporters. The invalid values are highlighted.\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
102,760,448 B (100.0%) -- explicit\n\
|
|
├──157,286,400 B (153.06%) -- js [?!]\n\
|
|
│ └──157,286,400 B (153.06%) -- compartment(http://too-big.com/) [?!]\n\
|
|
│ └──157,286,400 B (153.06%) ── stuff [?!]\n\
|
|
├────5,242,880 B (05.10%) ── ok\n\
|
|
├───-2,097,152 B (-2.04%) ── neg1 [?!]\n\
|
|
└──-57,671,680 B (-56.12%) ── heap-unclassified [?!]\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
104,857,600 B ── heap-allocated\n\
|
|
-111 B ── other1 [?!]\n\
|
|
-232,783,872 B ── other2 [?!]\n\
|
|
-333 ── other3 [?!]\n\
|
|
-444 ── other4 [?!]\n\
|
|
-5.55% ── other5 [?!]\n\
|
|
666.66% ── other6-danger<script>window.alert(1)</script> [?!]\n\
|
|
\n\
|
|
5th Process\n\
|
|
\n\
|
|
WARNING: the following values are negative or unreasonably large.\n\
|
|
explicit/a/neg2\n\
|
|
explicit/a/neg1\n\
|
|
explicit/b\n\
|
|
explicit/b/c\n\
|
|
explicit/b/c/d\n\
|
|
explicit/b/c/d/f\n\
|
|
This indicates a defect in one or more memory reporters. The invalid values are highlighted.\n\
|
|
\n\
|
|
Explicit Allocations\n\
|
|
104,801,280 B (100.0%) -- explicit\n\
|
|
├──103,809,024 B (99.05%) ── big\n\
|
|
├────1,007,616 B (00.96%) ── heap-unclassified\n\
|
|
├───────10,240 B (00.01%) -- a\n\
|
|
│ ├──40,960 B (00.04%) ── pos\n\
|
|
│ ├──-10,240 B (-0.01%) ── neg2 [?!]\n\
|
|
│ └──-20,480 B (-0.02%) ── neg1 [?!]\n\
|
|
└──────-25,600 B (-0.02%) -- b [?!]\n\
|
|
└──-25,600 B (-0.02%) -- c [?!]\n\
|
|
├───10,240 B (00.01%) -- g\n\
|
|
│ └──10,240 B (00.01%) ── h\n\
|
|
├────5,120 B (00.00%) -- i\n\
|
|
│ └──5,120 B (00.00%) ── j\n\
|
|
└──-40,960 B (-0.04%) -- d [?!]\n\
|
|
├───20,480 B (00.02%) ── e\n\
|
|
└──-61,440 B (-0.06%) ── f [?!]\n\
|
|
\n\
|
|
Other Measurements\n\
|
|
104,857,600 B ── heap-allocated\n\
|
|
\n\
|
|
"
|
|
|
|
function finish()
|
|
{
|
|
// Unregister fake reporters and multi-reporters, re-register the real
|
|
// reporters and multi-reporters, just in case subsequent tests rely on
|
|
// them.
|
|
for (var i = 0; i < fakeReporters.length; i++) {
|
|
mgr.unregisterReporter(fakeReporters[i]);
|
|
}
|
|
for (var i = 0; i < fakeMultiReporters.length; i++) {
|
|
mgr.unregisterMultiReporter(fakeMultiReporters[i]);
|
|
}
|
|
for (var i = 0; i < realReporters.length; i++) {
|
|
mgr.registerReporter(realReporters[i]);
|
|
}
|
|
for (var i = 0; i < realMultiReporters.length; i++) {
|
|
mgr.registerMultiReporter(realMultiReporters[i]);
|
|
}
|
|
SimpleTest.finish();
|
|
}
|
|
|
|
var gHaveDumped = false;
|
|
|
|
function checkClipboard(actual, expected) {
|
|
if (actual != expected) {
|
|
if (!gHaveDumped) {
|
|
dump("******EXPECTED******\n");
|
|
dump(expected);
|
|
dump("*******ACTUAL*******\n");
|
|
dump(actual);
|
|
dump("********************\n");
|
|
gHaveDumped = true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Cut+paste the entire page and check that the cut text matches what we
|
|
// expect. This tests the output in general and also that the cutting and
|
|
// pasting works as expected.
|
|
function test(aFrame, aExpectedText, aNext) {
|
|
SimpleTest.executeSoon(function() {
|
|
document.getElementById(aFrame).focus();
|
|
SimpleTest.waitForClipboard(
|
|
function(actual) { return checkClipboard(actual, aExpectedText) },
|
|
function() {
|
|
synthesizeKey("A", {accelKey: true});
|
|
synthesizeKey("C", {accelKey: true});
|
|
},
|
|
aNext,
|
|
function() {
|
|
ok(false, "pasted text doesn't match for " + aFrame);
|
|
finish();
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
addLoadEvent(function() {
|
|
test(
|
|
"amFrame",
|
|
amExpectedText,
|
|
function() {
|
|
test(
|
|
"amvFrame",
|
|
amvExpectedText,
|
|
function() {
|
|
finish()
|
|
}
|
|
)
|
|
}
|
|
);
|
|
});
|
|
SimpleTest.waitForExplicitFinish();
|
|
]]>
|
|
</script>
|
|
</window>
|