Upload Kmake

test/fixtures/wpt/streams/transferable/resources/create-wasm-module.js

@@ -0,0 +1,11 @@
+// There aren't many cloneable types that will cause an error on
+// deserialization. WASM modules have the property that it's an error to
+// deserialize them cross-site, which works for our purposes.
+async function createWasmModule() {
+  // It doesn't matter what the module is, so we use one from another
+  // test.
+  const response =
+        await fetch("/wasm/serialization/module/resources/incrementer.wasm");
+  const ab = await response.arrayBuffer();
+  return WebAssembly.compile(ab);
+}

test/fixtures/wpt/streams/transferable/resources/deserialize-error-frame.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="create-wasm-module.js"></script>
+<script>
+async_test(t => {
+  parent.postMessage('init done', '*');
+  window.addEventListener('message', async evt => {
+    if (evt.data.constructor.name !== 'WritableStream') {
+      return;
+    }
+    const ws = evt.data;
+    const writer = ws.getWriter();
+    const module = await createWasmModule();
+    writer.write(module);
+    await promise_rejects_dom(t, 'DataCloneError', writer.closed,
+                              'should reject with a DataCloneError');
+    t.done();
+    // Signal that this test is done. When both tests are done the iframe will
+    // be removed.
+    parent.postMessage('ws done', '*');
+  });
+}, 'a WritableStream deserialization failure should result in a DataCloneError');
+
+async_test(t => {
+  window.addEventListener('message', async evt => {
+    if (evt.data.constructor.name !== 'ReadableStream') {
+      return;
+    }
+    const rs = evt.data;
+    const reader = rs.getReader();
+    await promise_rejects_dom(t, 'DataCloneError', reader.read(),
+                              'should reject with a DataCloneError');
+    t.done();
+    // Signal that this test is done. When both tests are done the iframe will
+    // be removed.
+    parent.postMessage('rs done', '*');
+  });
+}, 'a ReadableStream deserialization failure should result in a DataCloneError');
+</script>

test/fixtures/wpt/streams/transferable/resources/echo-iframe.html

@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script>
+addEventListener('message', evt => {
+  evt.source.postMessage(evt.data, '*', [evt.data]);
+});
+</script>

test/fixtures/wpt/streams/transferable/resources/echo-worker.js

@@ -0,0 +1,2 @@
+// A worker that just transfers back any message that is sent to it.
+onmessage = evt => postMessage(evt.data, [evt.data]);

test/fixtures/wpt/streams/transferable/resources/helpers.js

@@ -0,0 +1,132 @@
+'use strict';
+
+(() => {
+  // Create a ReadableStream that will pass the tests in
+  // testTransferredReadableStream(), below.
+  function createOriginalReadableStream() {
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue('a');
+        controller.close();
+      }
+    });
+  }
+
+  // Common tests to roughly determine that |rs| is a correctly transferred
+  // version of a stream created by createOriginalReadableStream().
+  function testTransferredReadableStream(rs) {
+    assert_equals(rs.constructor, ReadableStream,
+                  'rs should be a ReadableStream in this realm');
+    assert_true(rs instanceof ReadableStream,
+                'instanceof check should pass');
+
+    // Perform a brand-check on |rs| in the process of calling getReader().
+    const reader = ReadableStream.prototype.getReader.call(rs);
+
+    return reader.read().then(({value, done}) => {
+      assert_false(done, 'done should be false');
+      assert_equals(value, 'a', 'value should be "a"');
+      return reader.read();
+    }).then(({done}) => {
+      assert_true(done, 'done should be true');
+    });
+  }
+
+  function testMessage(msg) {
+    assert_array_equals(msg.ports, [], 'there should be no ports in the event');
+    return testTransferredReadableStream(msg.data);
+  }
+
+  function testMessageEvent(target) {
+    return new Promise((resolve, reject) => {
+      target.addEventListener('message', ev => {
+        try {
+          resolve(testMessage(ev));
+        } catch (e) {
+          reject(e);
+        }
+      }, {once: true});
+    });
+  }
+
+  function testMessageEventOrErrorMessage(target) {
+    return new Promise((resolve, reject) => {
+      target.addEventListener('message', ev => {
+        if (typeof ev.data === 'string') {
+          // Assume it's an error message and reject with it.
+          reject(ev.data);
+          return;
+        }
+
+        try {
+          resolve(testMessage(ev));
+        } catch (e) {
+          reject(e);
+        }
+      }, {once: true});
+    });
+  }
+
+  function checkTestResults(target) {
+    return new Promise((resolve, reject) => {
+      target.onmessage = msg => {
+        // testharness.js sends us objects which we need to ignore.
+        if (typeof msg.data !== 'string')
+        return;
+
+        if (msg.data === 'OK') {
+          resolve();
+        } else {
+          reject(msg.data);
+        }
+      };
+    });
+  }
+
+  // These tests assume that a transferred ReadableStream will behave the same
+  // regardless of how it was transferred. This enables us to simply transfer the
+  // stream to ourselves.
+  function createTransferredReadableStream(underlyingSource) {
+    const original = new ReadableStream(underlyingSource);
+    const promise = new Promise((resolve, reject) => {
+      addEventListener('message', msg => {
+        const rs = msg.data;
+        if (rs instanceof ReadableStream) {
+          resolve(rs);
+        } else {
+          reject(new Error(`what is this thing: "${rs}"?`));
+        }
+      }, {once: true});
+    });
+    postMessage(original, '*', [original]);
+    return promise;
+  }
+
+  function recordingTransferredReadableStream(underlyingSource, strategy) {
+    const original = recordingReadableStream(underlyingSource, strategy);
+    const promise = new Promise((resolve, reject) => {
+      addEventListener('message', msg => {
+        const rs = msg.data;
+        if (rs instanceof ReadableStream) {
+          rs.events = original.events;
+          rs.eventsWithoutPulls = original.eventsWithoutPulls;
+          rs.controller = original.controller;
+          resolve(rs);
+        } else {
+          reject(new Error(`what is this thing: "${rs}"?`));
+        }
+      }, {once: true});
+    });
+    postMessage(original, '*', [original]);
+    return promise;
+  }
+
+  self.createOriginalReadableStream = createOriginalReadableStream;
+  self.testMessage = testMessage;
+  self.testMessageEvent = testMessageEvent;
+  self.testMessageEventOrErrorMessage = testMessageEventOrErrorMessage;
+  self.checkTestResults = checkTestResults;
+  self.createTransferredReadableStream = createTransferredReadableStream;
+  self.recordingTransferredReadableStream = recordingTransferredReadableStream;
+
+})();

test/fixtures/wpt/streams/transferable/resources/receiving-shared-worker.js

@@ -0,0 +1,11 @@
+'use strict';
+importScripts('/resources/testharness.js', 'helpers.js');
+
+onconnect = evt => {
+  const port = evt.source;
+  const promise = testMessageEvent(port);
+  port.start();
+  promise
+      .then(() => port.postMessage('OK'))
+      .catch(err => port.postMessage(`BAD: ${err}`));
+};

test/fixtures/wpt/streams/transferable/resources/receiving-worker.js

@@ -0,0 +1,7 @@
+'use strict';
+importScripts('/resources/testharness.js', 'helpers.js');
+
+const promise = testMessageEvent(self);
+promise
+    .then(() => postMessage('OK'))
+    .catch(err => postMessage(`BAD: ${err}`));

test/fixtures/wpt/streams/transferable/resources/sending-shared-worker.js

@@ -0,0 +1,12 @@
+'use strict';
+importScripts('helpers.js');
+
+onconnect = msg => {
+  const port = msg.source;
+  const orig = createOriginalReadableStream();
+  try {
+    port.postMessage(orig, [orig]);
+  } catch (e) {
+    port.postMessage(e.message);
+  }
+};

test/fixtures/wpt/streams/transferable/resources/sending-worker.js

@@ -0,0 +1,5 @@
+'use strict';
+importScripts('helpers.js');
+
+const orig = createOriginalReadableStream();
+postMessage(orig, [orig]);

test/fixtures/wpt/streams/transferable/resources/service-worker-iframe.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script src="/resources/testharness.js"></script>
+<script src="helpers.js"></script>
+<script>
+'use strict';
+
+setup({
+  explicit_done: true
+});
+
+function startTests() {
+  promise_test(() => {
+    const orig = createOriginalReadableStream();
+    const promise = checkTestResults(navigator.serviceWorker);
+    navigator.serviceWorker.controller.postMessage(orig, [orig]);
+    assert_true(orig.locked, 'the original stream should be locked');
+    return promise;
+  }, 'serviceWorker.controller.postMessage should be able to transfer a ' +
+               'ReadableStream');
+
+  promise_test(() => {
+    const promise = testMessageEventOrErrorMessage(navigator.serviceWorker);
+    navigator.serviceWorker.controller.postMessage('SEND');
+    return promise;
+  }, 'postMessage in a service worker should be able to transfer ReadableStream');
+
+  done();
+}
+
+// Delay running the tests until we get a message from the page telling us to.
+// This is to work around an issue where testharness.js doesn't detect
+// completion of the tests if they fail too early.
+onmessage = msg => {
+  if (msg.data === 'explicit trigger')
+    startTests();
+};
+
+</script>

test/fixtures/wpt/streams/transferable/resources/service-worker.js

@@ -0,0 +1,30 @@
+'use strict';
+importScripts('/resources/testharness.js', 'helpers.js');
+
+onmessage = msg => {
+  const client = msg.source;
+  if (msg.data === 'SEND') {
+    sendingTest(client);
+  } else {
+    receivingTest(msg, client);
+  }
+};
+
+function sendingTest(client) {
+  const orig = createOriginalReadableStream();
+  try {
+    client.postMessage(orig, [orig]);
+  } catch (e) {
+    client.postMessage(e.message);
+  }
+}
+
+function receivingTest(msg, client) {
+  try {
+    msg.waitUntil(testMessage(msg)
+                  .then(() => client.postMessage('OK'))
+                  .catch(e => client.postMessage(`BAD: ${e}`)));
+  } catch (e) {
+    client.postMessage(`BAD: ${e}`);
+  }
+}