Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- Manifest: dom/bindings/test/chrome.toml
<!DOCTYPE HTML>
<html>
<!--
-->
<head>
<meta charset="utf-8">
<script src="file_reflected_attribute_frozenarray.js"></script>
</head>
<body>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=787070">Mozilla Bug 787070</a>
<p id="display"></p>
<div id="content" style="display: none">
<iframe id="t"></iframe>
</div>
<pre id="test">
<script type="application/javascript">
// values should contain the values that the property should have on each of
// the objects on the prototype chain of obj. A value of undefined signals
// that the value should not be present on that prototype.
function checkXrayProperty(obj, name, values) {
var instance = obj;
do {
var value = values.shift();
if (typeof value == "undefined") {
ok(!obj.hasOwnProperty(name), "hasOwnProperty shouldn't see \"" + String(name) + "\" through Xrays");
is(Object.getOwnPropertyDescriptor(obj, name), undefined, "getOwnPropertyDescriptor shouldn't see \"" + String(name) + "\" through Xrays");
ok(!Object.keys(obj).includes(name), "Enumerating the Xray should not return \"" + String(name) + "\"");
ok(!Object.getOwnPropertyNames(obj).includes(name),
`The Xray's property names should not include ${String(name)}`);
ok(!Object.getOwnPropertySymbols(obj).includes(name),
`The Xray's property symbols should not include ${String(name)}`);
} else {
ok(obj.hasOwnProperty(name), "hasOwnProperty should see \"" + String(name) + "\" through Xrays");
var pd = Object.getOwnPropertyDescriptor(obj, name);
ok(pd, "getOwnPropertyDescriptor should see \"" + String(name) + "\" through Xrays");
if (pd && pd.get) {
is(pd.get.call(instance), value, "Should get the right value for \"" + String(name) + "\" through Xrays");
} else {
is(obj[name], value, "Should get the right value for \"" + String(name) + "\" through Xrays");
}
if (pd) {
if (pd.enumerable) {
ok(Object.keys(obj).indexOf("" + name) > -1, "Enumerating the Xray should return \"" + String(name) + "\"");
}
if (typeof name == "symbol") {
ok(Object.getOwnPropertySymbols(obj).includes(name),
`The Xray's property symbols should include ${String(name)}`);
} else {
ok(Object.getOwnPropertyNames(obj).includes("" + name),
`The Xray's property names should include ${name}`);
}
}
}
} while ((obj = Object.getPrototypeOf(obj)));
}
function checkWindowXrayProperty(win, name, { windowValue, windowPrototypeValue, namedPropertiesValue, eventTargetPrototypeValue }) {
checkXrayProperty(win, name, [ windowValue, windowPrototypeValue, namedPropertiesValue, eventTargetPrototypeValue ]);
}
function checkDocumentXrayProperty(doc, name, { documentValue, htmlDocumentPrototypeValue, documentPrototypeValue, nodePrototypeValue, eventTargetPrototypeValue }) {
checkXrayProperty(doc, name, [ documentValue, htmlDocumentPrototypeValue, documentPrototypeValue, nodePrototypeValue, eventTargetPrototypeValue ]);
}
function loadFrame() {
let frame = document.getElementById("t");
let win = frame.contentWindow;
let { promise: loaded, resolve } = Promise.withResolvers();
frame.addEventListener("load", resolve, { once: true });
return loaded.then(() => ({ frame, win, doc: frame.contentDocument }));
}
async function test() {
// Window
let { frame, win, doc } = await loadFrame();
var winProto = Object.getPrototypeOf(win);
is(winProto, win.Window.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
var namedPropertiesObject = Object.getPrototypeOf(winProto);
is(Cu.getClassName(namedPropertiesObject, /* unwrap = */ true), "WindowProperties", "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
var eventTargetProto = Object.getPrototypeOf(namedPropertiesObject);
is(eventTargetProto, win.EventTarget.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
let docProto = Object.getPrototypeOf(doc);
is(docProto, win.HTMLDocument.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
// Xrays need to filter expandos.
checkDocumentXrayProperty(doc, "expando", {});
ok(!("expando" in doc), "Xrays should filter expandos");
checkDocumentXrayProperty(doc, "shadowedIframe", {});
ok(!("shadowedIframe" in doc), "Named properties should not be exposed through Xrays");
// Named properties live on the named properties object for global objects,
// but are not exposed via Xrays.
checkWindowXrayProperty(win, "iframe", {});
ok(!("iframe" in win), "Named properties should not be exposed through Xrays");
// Window properties live on the instance, shadowing the properties of the named property object.
checkWindowXrayProperty(win, "document", { windowValue: doc });
ok("document" in win, "WebIDL properties should be exposed through Xrays");
// Unforgeable properties live on the instance, shadowing the properties of the named property object.
checkWindowXrayProperty(win, "self", { windowValue: win });
ok("self" in win, "WebIDL properties should be exposed through Xrays");
// Named properties live on the instance for non-global objects, but are not
// exposed via Xrays.
checkDocumentXrayProperty(doc, "iframe", {});
ok(!("iframe" in doc), "Named properties should not be exposed through Xrays");
// Object.prototype is at the end of the prototype chain.
var obj = win;
var proto;
while ((proto = Object.getPrototypeOf(obj))) {
obj = proto;
}
is(obj, win.Object.prototype, "Object.prototype should be at the end of the prototype chain");
// Named properties shouldn't shadow WebIDL- or ECMAScript-defined properties.
checkWindowXrayProperty(win, "addEventListener", { eventTargetPrototypeValue: eventTargetProto.addEventListener });
is(win.addEventListener, eventTargetProto.addEventListener, "Named properties shouldn't shadow WebIDL-defined properties");
is(win.toString, win.Object.prototype.toString, "Named properties shouldn't shadow ECMAScript-defined properties");
// WebIDL interface names should be exposed.
var waivedWin = Cu.waiveXrays(win);
checkWindowXrayProperty(win, "Element", { windowValue: Cu.unwaiveXrays(waivedWin.Element) });
// JS standard classes should be exposed.
checkWindowXrayProperty(win, "Array", { windowValue: Cu.unwaiveXrays(waivedWin.Array) });
// HTMLDocument
// Unforgeable properties live on the instance.
checkXrayProperty(doc, "location", [ win.location ]);
is(String(win.location), frame.src,
"Should have the right stringification");
// HTMLHtmlElement
var elem = doc.documentElement;
var elemProto = Object.getPrototypeOf(elem);
is(elemProto, win.HTMLHtmlElement.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
elemProto = Object.getPrototypeOf(elemProto);
is(elemProto, win.HTMLElement.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
elemProto = Object.getPrototypeOf(elemProto);
is(elemProto, win.Element.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
elemProto = Object.getPrototypeOf(elemProto);
is(elemProto, win.Node.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
elemProto = Object.getPrototypeOf(elemProto);
is(elemProto, win.EventTarget.prototype, "The proto chain of the Xray should mirror the prototype chain of the Xrayed object");
// Xrays need to filter expandos.
ok(!("expando" in elem), "Xrays should filter expandos");
// WebIDL-defined properties live on the prototype.
checkXrayProperty(elem, "version", [ undefined, "" ]);
is(elem.version, "", "WebIDL properties should be exposed through Xrays");
// HTMLCollection
var coll = doc.getElementsByTagName("div");
// Named properties live on the instance for non-global objects.
checkXrayProperty(coll, "iframe", [ doc.getElementById("iframe") ]);
// Indexed properties live on the instance.
checkXrayProperty(coll, 0, [ doc.getElementById("shadowedIframe") ]);
// WebIDL-defined properties live on the prototype, overriding any named properties.
checkXrayProperty(coll, "item", [ undefined, win.HTMLCollection.prototype.item ]);
// ECMAScript-defined properties live on the prototype, overriding any named properties.
checkXrayProperty(coll, "toString", [ undefined, undefined, win.Object.prototype.toString ]);
// Constructors
img = new win.Image();
ok(win.HTMLImageElement.isInstance(img), "Constructor created the right type of object");
let threw;
try {
threw = false;
win.Image();
} catch (e) {
threw = true;
}
ok(threw, "Constructors should throw when called without new");
try {
threw = false;
new win.Node();
} catch (e) {
threw = true;
}
ok(threw, "Constructing an interface without a constructor should throw");
// Frozen arrays should come from our compartment, not the target one.
var languages1 = win.navigator.languages;
isnot(languages1, undefined, "Must have .languages");
ok(Array.isArray(languages1), ".languages should be an array");
ok(Object.isFrozen(languages1), ".languages should be a frozen array");
ok(!Cu.isXrayWrapper(languages1), "Should have our own version of array");
is(Cu.getGlobalForObject(languages1), window,
"languages1 should come from our window");
// We want to get .languages in the content compartment, but without waiving
// Xrays altogether.
var languages2 = win.eval("navigator.languages");
isnot(languages2, undefined, "Must still have .languages");
ok(Array.isArray(languages2), ".languages should still be an array");
ok(Cu.isXrayWrapper(languages2), "Should have xray for content version of array");
is(Cu.getGlobalForObject(languages2), win,
"languages2 come from the underlying window");
ok(Object.isFrozen(languages2.wrappedJSObject),
".languages should still be a frozen array underneath");
isnot(languages1, languages2, "Must have distinct arrays");
isnot(languages1, languages2.wrappedJSObject,
"Must have distinct arrays no matter how we slice it");
// Check that deleters work correctly in the [OverrideBuiltins] case.
elem = win.document.documentElement;
var dataset = elem.dataset;
is(dataset.foo, undefined, "Should not have a 'foo' property");
ok(!("foo" in dataset), "Really should not have a 'foo' property");
is(elem.getAttribute("data-foo"), null,
"Should not have a 'data-foo' attribute");
ok(!elem.hasAttribute("data-foo"),
"Really should not have a 'data-foo' attribute");
dataset.foo = "bar";
is(dataset.foo, "bar", "Should now have a 'foo' property");
ok("foo" in dataset, "Really should have a 'foo' property");
is(elem.getAttribute("data-foo"), "bar",
"Should have a 'data-foo' attribute");
ok(elem.hasAttribute("data-foo"),
"Really should have a 'data-foo' attribute");
delete dataset.foo;
is(dataset.foo, undefined, "Should not have a 'foo' property again");
ok(!("foo" in dataset), "Really should not have a 'foo' property again");
is(elem.getAttribute("data-foo"), null,
"Should not have a 'data-foo' attribute again");
ok(!elem.hasAttribute("data-foo"),
"Really should not have a 'data-foo' attribute again");
// Check that deleters work correctly in the non-[OverrideBuiltins] case.
var storage = win.sessionStorage;
is(storage.foo, undefined, "Should not have a 'foo' property");
ok(!("foo" in storage), "Really should not have a 'foo' property");
is(storage.getItem("foo"), null, "Should not have an item named 'foo'");
storage.foo = "bar";
is(storage.foo, "bar", "Should have a 'foo' property");
ok("foo" in storage, "Really should have a 'foo' property");
is(storage.getItem("foo"), "bar", "Should have an item named 'foo'");
delete storage.foo;
is(storage.foo, undefined, "Should not have a 'foo' property again");
ok(!("foo" in storage), "Really should not have a 'foo' property again");
is(storage.getItem("foo"), null, "Should not have an item named 'foo' again");
// Non-static properties are not exposed on interface objects or instances.
is(win.HTMLInputElement.checkValidity, undefined,
"Shouldn't see non-static property on interface objects");
is(Object.getOwnPropertyDescriptor(win.HTMLInputElement, "checkValidity"), undefined,
"Shouldn't see non-static property on interface objects");
is(Object.getOwnPropertyNames(win.HTMLInputElement).indexOf("checkValidity"), -1,
"Shouldn't see non-static property on interface objects");
isnot(typeof doc.createElement("input").checkValidity, "undefined",
"Should see non-static property on prototype objects");
is(Object.getOwnPropertyDescriptor(doc.createElement("input"), "checkValidity"), undefined,
"Shouldn't see non-static property on instances");
isnot(typeof Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, "checkValidity"), "undefined",
"Should see non-static property on prototype objects");
// Static properties are not exposed on prototype objects or instances.
isnot(typeof win.URL.createObjectURL, "undefined",
"Should see static property on interface objects");
isnot(typeof Object.getOwnPropertyDescriptor(win.URL, "createObjectURL"), "undefined",
"Should see static property on interface objects");
isnot(Object.getOwnPropertyNames(win.URL).indexOf("createObjectURL"), -1,
"Should see static property on interface objects");
"Shouldn't see static property on instances and prototype ojbects");
"Shouldn't see static property on instances");
is(Object.getOwnPropertyDescriptor(win.URL.prototype, "createObjectURL"), undefined,
"Shouldn't see static property on prototype objects");
// Unforgeable properties are not exposed on prototype objects or interface
// objects.
is(Window.document, undefined,
"Shouldn't see unforgeable property on interface objects");
is(Object.getOwnPropertyDescriptor(Window, "document"), undefined,
"Shouldn't see unforgeable property on interface objects");
is(Object.getOwnPropertyNames(Window).indexOf("document"), -1,
"Shouldn't see unforgeable property on interface objects");
isnot(typeof win.document, "undefined",
"Should see unforgeable property on instances");
isnot(typeof Object.getOwnPropertyDescriptor(win, "document"), "undefined",
"Should see unforgeable property on instances");
is(Object.getOwnPropertyDescriptor(Window.prototype, "document"), undefined,
"Shouldn't see unforgeable property on prototype objects");
// Constant properties are not exposted on instances.
isnot(typeof win.Node.ELEMENT_NODE, "undefined",
"Should see constant property on interface objects");
isnot(typeof Object.getOwnPropertyDescriptor(win.Node, "ELEMENT_NODE"), "undefined",
"Should see constant property on interface objects");
isnot(Object.getOwnPropertyNames(win.Node).indexOf("ELEMENT_NODE"), -1,
"Should see constant property on interface objects");
isnot(typeof elem.ELEMENT_NODE, "undefined",
"Should see constant property on prototype objects");
is(Object.getOwnPropertyDescriptor(elem, "ELEMENT_NODE"), undefined,
"Shouldn't see constant property on instances");
isnot(typeof Object.getOwnPropertyDescriptor(win.Node.prototype, "ELEMENT_NODE"), "undefined",
"Should see constant property on prototype objects");
// Interfaces can have both static and non-static properties with the same name.
isnot(typeof win.TestFunctions.staticAndNonStaticOverload, "undefined",
"Should see static property on interface objects (even with non-static property with the same name)");
isnot(typeof Object.getOwnPropertyDescriptor(win.TestFunctions, "staticAndNonStaticOverload"), "undefined",
"Should see static property on interface objects (even with non-static property with the same name)");
isnot(Object.getOwnPropertyNames(win.TestFunctions).indexOf("staticAndNonStaticOverload"), -1,
"Should see static property on interface objects (even with non-static property with the same name)");
isnot(typeof (new win.TestFunctions("")).staticAndNonStaticOverload, "undefined",
"Should see non-static property on prototype objects (even with static property with the same name)");
let testFunctions = new win.TestFunctions();
is(Object.getOwnPropertyDescriptor(testFunctions, "staticAndNonStaticOverload"), undefined,
"Shouldn't see non-static property on instances (even with static property with the same name)");
ok(!testFunctions.staticAndNonStaticOverload(),
"Should call the non-static overload on the instance");
ok(win.TestFunctions.staticAndNonStaticOverload(),
"Should call the static overload on the interface object");
isnot(typeof Object.getOwnPropertyDescriptor(win.TestFunctions.prototype, "staticAndNonStaticOverload"), "undefined",
"Should see non-static property on prototype objects (even with static property with the same name)");
is(Object.getOwnPropertyDescriptor(win.TestFunctions, "staticAndNonStaticOverload").value,
Object.getOwnPropertyDescriptor(win.TestFunctions, "staticAndNonStaticOverload").value,
"Should get the same value when getting the static property twice");
is(Object.getOwnPropertyDescriptor(win.TestFunctions.prototype, "staticAndNonStaticOverload").value,
Object.getOwnPropertyDescriptor(win.TestFunctions.prototype, "staticAndNonStaticOverload").value,
"Should get the same value when getting the non-static property twice");
isnot(Object.getOwnPropertyDescriptor(win.TestFunctions, "staticAndNonStaticOverload").value,
Object.getOwnPropertyDescriptor(win.TestFunctions.prototype, "staticAndNonStaticOverload").value,
"Should get different values for static and non-static properties with the same name");
// Adopting nodes should not lose expandos.
elem = document.createElement("span");
elem.expando = 5;
is(elem.expando, 5, "We just set this property");
document.adoptNode(elem);
is(elem.wrappedJSObject, undefined, "Shouldn't be an Xray anymore");
is(elem.expando, 5, "Expando should not get lost");
// Instanceof tests
var img = doc.createElement("img");
var img2 = document.createElement("img");
ok(img instanceof win.HTMLImageElement,
"Should be an instance of HTMLImageElement from its global");
ok(win.HTMLImageElement.isInstance(img), "isInstance should work");
ok(HTMLImageElement.isInstance(img), "isInstance should work cross-global");
ok(win.HTMLImageElement.isInstance(img2),
"isInstance should work cross-global in the other direction");
ok(img instanceof win.Image,
"Should be an instance of Image, because Image.prototype == HTMLImageElement.prototype");
ok(!win.Image.isInstance, "Shouldn't have an isInstance method here");
// Image does not have a Symbol.hasInstance, but its proto
// (Function.prototype) does.
checkXrayProperty(win.Image, Symbol.hasInstance,
[undefined, win.Function.prototype[Symbol.hasInstance]]);
// toString/@@toStringTag
let imageConstructor = win.Image;
is(win.Function.prototype.toString.apply(imageConstructor),
Function.prototype.toString.apply(Image),
"Applying Function.prototype.toString through an Xray should give the same result as applying it directly");
isDeeply(Object.getOwnPropertyDescriptor(win.CSS, Symbol.toStringTag),
Object.getOwnPropertyDescriptor(CSS, Symbol.toStringTag),
"Getting @@toStringTag on a namespace object through an Xray should give the same result as getting it directly");
// legacyCaller should work.
ok(win.HTMLAllCollection.isInstance(doc.all),
"HTMLDocument.all should be an instance of HTMLAllCollection");
let element;
try {
threw = false;
element = doc.all(0);
} catch (e) {
threw = true;
}
ok(!threw,
"Calling an instance object for an interface marked with legacycaller shouldn't throw");
checkXrayProperty(doc.all, 0, [ element ]);
let [ testObject, expectedValues ] = testReflectedAttributeWithFrozenArray(win);
checkReflectedAttributeWithFrozenArray(testObject.wrappedJSObject, expectedValues,
"on Xray and object",
(a, b) => a.wrappedJSObject == b);
// Load the frame again, so we get a pristine global.
({ frame, win, doc } = await loadFrame());
is(win.wrappedJSObject.TestChromeOnlyInterface, undefined,
"A ChromeOnly interface shouldn't be exposed on a non-system global");
obj = win.TestFunctions.createTestChromeOnlyInterface();
ok(Cu.isXrayWrapper(obj), "Object should be wrapped in an Xray");
is(win.wrappedJSObject.TestChromeOnlyInterface, undefined,
"A ChromeOnly interface should still not be exposed on a non-system global");
SimpleTest.finish();
}
SimpleTest.waitForExplicitFinish();
SimpleTest.requestLongerTimeout(2);
addLoadEvent(() => {
SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]},
test);
});
</script>
</pre>
</body>
</html>