diff options
Diffstat (limited to 'dom/bindings/test/test_dom_xrays.html')
| -rw-r--r-- | dom/bindings/test/test_dom_xrays.html | 386 |
1 files changed, 386 insertions, 0 deletions
diff --git a/dom/bindings/test/test_dom_xrays.html b/dom/bindings/test/test_dom_xrays.html new file mode 100644 index 0000000000..6d65ab7315 --- /dev/null +++ b/dom/bindings/test/test_dom_xrays.html @@ -0,0 +1,386 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=787070 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 787070</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/> +</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" src="http://example.org/tests/dom/bindings/test/file_dom_xrays.html"></iframe> +</div> +<pre id="test"> +<script type="application/javascript"> + +/** Test for Bug 1021066 **/ + +// 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 test() { + // Window + var win = document.getElementById("t").contentWindow; + var doc = document.getElementById("t").contentDocument; + + 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), document.getElementById("t").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("iframe"); + + // 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 ]); + + // 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"); + is(new URL("http://example.org").createObjectURL, undefined, + "Shouldn't see static property on instances and prototype ojbects"); + is(Object.getOwnPropertyDescriptor(new URL("http://example.org"), "createObjectURL"), undefined, + "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, threw; + 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 ]); + + SimpleTest.finish(); +} + +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestLongerTimeout(2); + +addLoadEvent(() => { + SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]}, + test); +}); + +</script> +</pre> +</body> +</html> |