streams/readable-streams/global.html - external/github.com/web-platform-tests/wpt - Git at Google

 <!doctype html>
 <meta charset="utf-8">
 <title>Ensure Stream objects are created in expected globals. </title>

 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>

 <body></body>
 <script>
 // These tests are loosely derived from Gecko's readable-stream-globals.js,
 // which is a test case designed around the JS Streams implementation.
 //
 // Unlike in JS Streams, where function calls switch realms and change
 // the resulting global of the resulting objects, in WebIDL streams,
 // the global of an object is (currently underspecified, but) intended
 // to be the "Relevant Global" of the 'this' object.
 //
 // See:
 // https://html.spec.whatwg.org/multipage/webappapis.html#relevant
 // https://github.com/whatwg/streams/issues/1213
 "use strict"

 const iframe = document.createElement("iframe")
 document.body.append(iframe)

 const otherGlobal = iframe.contentWindow;
 const OtherReadableStream = otherGlobal.ReadableStream
 const OtherReadableStreamDefaultReader = otherGlobal.ReadableStreamDefaultReader;
 const OtherReadableStreamDefaultController = otherGlobal.ReadableStreamDefaultController;

 promise_test(async () => {

     // Controllers
     let controller;
     let otherController;

     // Get Stream Prototypes and controllers.
     let streamController;
     let stream = new ReadableStream({start(c) { streamController = c; }});

     const callReaderThisGlobal = OtherReadableStream.prototype.getReader.call(stream);
     const newReaderOtherGlobal = new OtherReadableStreamDefaultReader(new ReadableStream());

     // Relevant Global Checking.
     assert_equals(callReaderThisGlobal instanceof ReadableStreamDefaultReader, true, "reader was created in this global (.call)");
     assert_equals(newReaderOtherGlobal instanceof ReadableStreamDefaultReader, false, "reader was created in other global (new)");

     assert_equals(callReaderThisGlobal instanceof OtherReadableStreamDefaultReader, false, "reader isn't coming from other global (.call)" );
     assert_equals(newReaderOtherGlobal instanceof OtherReadableStreamDefaultReader, true, "reader isn't coming from other global (new)");

     assert_equals(otherController instanceof ReadableStreamDefaultController, false, "otherController should come from other gloal")


     const request = callReaderThisGlobal.read();
     assert_equals(request instanceof Promise, true, "Promise comes from this global");

     streamController.close();
     const requestResult = await request;
     assert_equals(requestResult instanceof Object, true, "returned object comes from this global");
 }, "Stream objects created in expected globals")

 promise_test(async () => {
     const stream = new ReadableStream();
     const otherReader = new OtherReadableStreamDefaultReader(stream);
     const cancelPromise = ReadableStreamDefaultReader.prototype.cancel.call(otherReader);
     assert_equals(cancelPromise instanceof Promise, true, "Cancel promise comes from the same global as the stream");
     assert_equals(await cancelPromise, undefined, "Cancel promise resolves to undefined");
 }, "Cancel promise is created in same global as stream")

 // Refresh the streams and controllers.
 function getFreshInstances() {
     let controller;
     let otherController;
     let stream = new ReadableStream({
         start(c) {
             controller = c;
         }
     });

     new OtherReadableStream({
         start(c) {
             otherController = c;
         }
     });

     return {stream, controller, otherController}
 }


 promise_test(async () => {
     // Test closed promise on reader from another global (connected to a this-global stream)
     const {stream, controller, otherController} = getFreshInstances();

     const otherReader = new OtherReadableStreamDefaultReader(stream);
     const closedPromise = otherReader.closed;
     assert_equals(closedPromise instanceof otherGlobal.Promise, true, "Closed promise in other global.");
 }, "Closed Promise in correct global");

 promise_test(async () => {
     const {stream, controller, otherController} = getFreshInstances();

     const otherReader = OtherReadableStream.prototype.getReader.call(stream);
     assert_equals(otherReader instanceof ReadableStreamDefaultReader, true, "Reader comes from this global")
     const request = otherReader.read();
     assert_equals(request instanceof Promise, true, "Promise still comes from stream's realm (this realm)");
     otherController.close.call(controller);
     assert_equals((await request) instanceof otherGlobal.Object, true, "Object comes from other realm");
 }, "Reader objects in correct global");


 promise_test(async () => {
     const {stream, controller, otherController} = getFreshInstances();
     assert_equals(controller.desiredSize, 1, "Desired size is expected");
     Object.defineProperty(controller, "desiredSize",
         Object.getOwnPropertyDescriptor(OtherReadableStreamDefaultController.prototype, "desiredSize"));
     assert_equals(controller.desiredSize, 1, "Grafting getter from other prototype still returns desired size");
 }, "Desired size can be grafted from one prototype to another");

 promise_test(async () => {
     const {stream, controller, otherController} = getFreshInstances();

     // Make sure the controller close method returns the correct TypeError
     const enqueuedError = { name: "enqueuedError" };
     controller.error(enqueuedError);

     assert_throws_js(TypeError, () => controller.close(),  "Current Global controller");
     assert_throws_js(otherGlobal.TypeError, () => otherController.close.call(controller),  "Other global controller");
 }, "Closing errored stream throws object in appropriate global")

 promise_test(async () => {
     const {otherController} = getFreshInstances();
     // We can enqueue chunks from multiple globals
     const chunk = { name: "chunk" };

     let controller;
     const stream = new ReadableStream({ start(c) { controller = c; } }, { size() {return 1} });
     otherController.enqueue.call(controller, chunk);
     otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10));
     controller.enqueue(new otherGlobal.Uint8Array(10));
 }, "Can enqueue chunks from multiple globals")

 promise_test(async () => {
     const {stream, controller, otherController} = getFreshInstances();
     const chunk = { name: "chunk" };

     // We get the correct type errors out of a closed stream.
     controller.close();
     assert_throws_js(TypeError, () => controller.enqueue(new otherGlobal.Uint8Array(10)));
     assert_throws_js(otherGlobal.TypeError, () => otherController.enqueue.call(controller, chunk));
     assert_throws_js(otherGlobal.TypeError, () => otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10)));
 }, "Correct errors and globals for closed streams");


 promise_test(async () => {
     const {stream, controller, otherController} = getFreshInstances();
     // Branches out of tee are in the correct global

     const [branch1, branch2] = otherGlobal.ReadableStream.prototype.tee.call(stream);
     assert_equals(branch1 instanceof ReadableStream, true, "Branch created in this global (as stream is in this global)");
     assert_equals(branch2 instanceof ReadableStream, true, "Branch created in this global (as stream is in this global)");
 }, "Tee Branches in correct global");
 </script>
	<!doctype html>
	<meta charset="utf-8">
	<title>Ensure Stream objects are created in expected globals. </title>

	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>

	<body></body>
	<script>
	// These tests are loosely derived from Gecko's readable-stream-globals.js,
	// which is a test case designed around the JS Streams implementation.
	//
	// Unlike in JS Streams, where function calls switch realms and change
	// the resulting global of the resulting objects, in WebIDL streams,
	// the global of an object is (currently underspecified, but) intended
	// to be the "Relevant Global" of the 'this' object.
	//
	// See:
	// https://html.spec.whatwg.org/multipage/webappapis.html#relevant
	// https://github.com/whatwg/streams/issues/1213
	"use strict"

	const iframe = document.createElement("iframe")
	document.body.append(iframe)

	const otherGlobal = iframe.contentWindow;
	const OtherReadableStream = otherGlobal.ReadableStream
	const OtherReadableStreamDefaultReader = otherGlobal.ReadableStreamDefaultReader;
	const OtherReadableStreamDefaultController = otherGlobal.ReadableStreamDefaultController;

	promise_test(async () => {

	// Controllers
	let controller;
	let otherController;

	// Get Stream Prototypes and controllers.
	let streamController;
	let stream = new ReadableStream({start(c) { streamController = c; }});

	const callReaderThisGlobal = OtherReadableStream.prototype.getReader.call(stream);
	const newReaderOtherGlobal = new OtherReadableStreamDefaultReader(new ReadableStream());

	// Relevant Global Checking.
	assert_equals(callReaderThisGlobal instanceof ReadableStreamDefaultReader, true, "reader was created in this global (.call)");
	assert_equals(newReaderOtherGlobal instanceof ReadableStreamDefaultReader, false, "reader was created in other global (new)");

	assert_equals(callReaderThisGlobal instanceof OtherReadableStreamDefaultReader, false, "reader isn't coming from other global (.call)" );
	assert_equals(newReaderOtherGlobal instanceof OtherReadableStreamDefaultReader, true, "reader isn't coming from other global (new)");

	assert_equals(otherController instanceof ReadableStreamDefaultController, false, "otherController should come from other gloal")


	const request = callReaderThisGlobal.read();
	assert_equals(request instanceof Promise, true, "Promise comes from this global");

	streamController.close();
	const requestResult = await request;
	assert_equals(requestResult instanceof Object, true, "returned object comes from this global");
	}, "Stream objects created in expected globals")

	promise_test(async () => {
	const stream = new ReadableStream();
	const otherReader = new OtherReadableStreamDefaultReader(stream);
	const cancelPromise = ReadableStreamDefaultReader.prototype.cancel.call(otherReader);
	assert_equals(cancelPromise instanceof Promise, true, "Cancel promise comes from the same global as the stream");
	assert_equals(await cancelPromise, undefined, "Cancel promise resolves to undefined");
	}, "Cancel promise is created in same global as stream")

	// Refresh the streams and controllers.
	function getFreshInstances() {
	let controller;
	let otherController;
	let stream = new ReadableStream({
	start(c) {
	controller = c;
	}
	});

	new OtherReadableStream({
	start(c) {
	otherController = c;
	}
	});

	return {stream, controller, otherController}
	}


	promise_test(async () => {
	// Test closed promise on reader from another global (connected to a this-global stream)
	const {stream, controller, otherController} = getFreshInstances();

	const otherReader = new OtherReadableStreamDefaultReader(stream);
	const closedPromise = otherReader.closed;
	assert_equals(closedPromise instanceof otherGlobal.Promise, true, "Closed promise in other global.");
	}, "Closed Promise in correct global");

	promise_test(async () => {
	const {stream, controller, otherController} = getFreshInstances();

	const otherReader = OtherReadableStream.prototype.getReader.call(stream);
	assert_equals(otherReader instanceof ReadableStreamDefaultReader, true, "Reader comes from this global")
	const request = otherReader.read();
	assert_equals(request instanceof Promise, true, "Promise still comes from stream's realm (this realm)");
	otherController.close.call(controller);
	assert_equals((await request) instanceof otherGlobal.Object, true, "Object comes from other realm");
	}, "Reader objects in correct global");


	promise_test(async () => {
	const {stream, controller, otherController} = getFreshInstances();
	assert_equals(controller.desiredSize, 1, "Desired size is expected");
	Object.defineProperty(controller, "desiredSize",
	Object.getOwnPropertyDescriptor(OtherReadableStreamDefaultController.prototype, "desiredSize"));
	assert_equals(controller.desiredSize, 1, "Grafting getter from other prototype still returns desired size");
	}, "Desired size can be grafted from one prototype to another");

	promise_test(async () => {
	const {stream, controller, otherController} = getFreshInstances();

	// Make sure the controller close method returns the correct TypeError
	const enqueuedError = { name: "enqueuedError" };
	controller.error(enqueuedError);

	assert_throws_js(TypeError, () => controller.close(), "Current Global controller");
	assert_throws_js(otherGlobal.TypeError, () => otherController.close.call(controller), "Other global controller");
	}, "Closing errored stream throws object in appropriate global")

	promise_test(async () => {
	const {otherController} = getFreshInstances();
	// We can enqueue chunks from multiple globals
	const chunk = { name: "chunk" };

	let controller;
	const stream = new ReadableStream({ start(c) { controller = c; } }, { size() {return 1} });
	otherController.enqueue.call(controller, chunk);
	otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10));
	controller.enqueue(new otherGlobal.Uint8Array(10));
	}, "Can enqueue chunks from multiple globals")

	promise_test(async () => {
	const {stream, controller, otherController} = getFreshInstances();
	const chunk = { name: "chunk" };

	// We get the correct type errors out of a closed stream.
	controller.close();
	assert_throws_js(TypeError, () => controller.enqueue(new otherGlobal.Uint8Array(10)));
	assert_throws_js(otherGlobal.TypeError, () => otherController.enqueue.call(controller, chunk));
	assert_throws_js(otherGlobal.TypeError, () => otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10)));
	}, "Correct errors and globals for closed streams");


	promise_test(async () => {
	const {stream, controller, otherController} = getFreshInstances();
	// Branches out of tee are in the correct global

	const [branch1, branch2] = otherGlobal.ReadableStream.prototype.tee.call(stream);
	assert_equals(branch1 instanceof ReadableStream, true, "Branch created in this global (as stream is in this global)");
	assert_equals(branch2 instanceof ReadableStream, true, "Branch created in this global (as stream is in this global)");
	}, "Tee Branches in correct global");
	</script>